#include "projectitem.h"
#include "commands/addfoldercommand.h"
#include "projecttree/proxyclipjob.h"
+#include "projecttree/cutclipjob.h"
+#include "projecttree/meltjob.h"
#include "kdenlivesettings.h"
#include "slideshowclip.h"
#include "ui_colorclip_ui.h"
#include "projectlistview.h"
#include "timecodedisplay.h"
#include "profilesdialog.h"
+#include "clipstabilize.h"
#include "commands/editclipcommand.h"
#include "commands/editclipcutcommand.h"
#include "commands/editfoldercommand.h"
#include "commands/addclipcutcommand.h"
#include "ui_templateclip_ui.h"
+#include "ui_cutjobdialog_ui.h"
+#include "ui_scenecutdialog_ui.h"
#include <KDebug>
#include <KAction>
#include <KApplication>
#include <KStandardDirs>
#include <KColorScheme>
+#include <KActionCollection>
+#include <KUrlRequester>
+#include <KVBox>
+#include <KHBox>
-#ifdef NEPOMUK
+#ifdef USE_NEPOMUK
#include <nepomuk/global.h>
#include <nepomuk/resourcemanager.h>
+#include <Nepomuk/Resource>
//#include <nepomuk/tag.h>
#endif
#include <QIcon>
#include <QMenu>
#include <QProcess>
+#include <QScrollBar>
#include <QHeaderView>
#include <QInputDialog>
#include <QtConcurrentRun>
#include <QVBoxLayout>
+#include <KPassivePopup>
+
+
+MyMessageWidget::MyMessageWidget(QWidget *parent) : KMessageWidget(parent) {}
+MyMessageWidget::MyMessageWidget(const QString &text, QWidget *parent) : KMessageWidget(text, parent) {}
+
+
+bool MyMessageWidget::event(QEvent* ev) {
+ if (ev->type() == QEvent::Hide || ev->type() == QEvent::Close) emit messageClosing();
+ return KMessageWidget::event(ev);
+}
SmallInfoLabel::SmallInfoLabel(QWidget *parent) : QPushButton(parent)
{
/*QString style = "QToolButton {background-color: %1;border-style: outset;border-width: 2px;
border-radius: 5px;border-color: beige;}";*/
- KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
+ m_timeLine = new QTimeLine(500, this);
+ QObject::connect(m_timeLine, SIGNAL(valueChanged(qreal)), this, SLOT(slotTimeLineChanged(qreal)));
+ QObject::connect(m_timeLine, SIGNAL(finished()), this, SLOT(slotTimeLineFinished()));
+ hide();
+}
+
+const QString SmallInfoLabel::getStyleSheet(const QPalette &p)
+{
+ KColorScheme scheme(p.currentColorGroup(), KColorScheme::Window, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
QColor bg = scheme.background(KColorScheme::LinkBackground).color();
QColor fg = scheme.foreground(KColorScheme::LinkText).color();
QString style = QString("QPushButton {padding:2px;background-color: rgb(%1, %2, %3);border-radius: 4px;border: none;color: rgb(%4, %5, %6)}").arg(bg.red()).arg(bg.green()).arg(bg.blue()).arg(fg.red()).arg(fg.green()).arg(fg.blue());
fg = scheme.foreground(KColorScheme::ActiveText).color();
style.append(QString("\nQPushButton:hover {padding:2px;background-color: rgb(%1, %2, %3);border-radius: 4px;border: none;color: rgb(%4, %5, %6)}").arg(bg.red()).arg(bg.green()).arg(bg.blue()).arg(fg.red()).arg(fg.green()).arg(fg.blue()));
- setStyleSheet(style);
- m_timeLine = new QTimeLine(500, this);
- QObject::connect(m_timeLine, SIGNAL(valueChanged(qreal)), this, SLOT(slotTimeLineChanged(qreal)));
- QObject::connect(m_timeLine, SIGNAL(finished()), this, SLOT(slotTimeLineFinished()));
- hide();
+ return style;
}
void SmallInfoLabel::slotTimeLineChanged(qreal value)
setToolTip(i18np("%1 pending job", "%1 pending jobs", jobCount));
if (!(KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects)) {
+ setFixedWidth(sizeHint().width());
show();
return;
}
}
else {
if (!(KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects)) {
+ setFixedWidth(0);
hide();
return;
}
m_commandStack(NULL),
m_openAction(NULL),
m_reloadAction(NULL),
- m_stabilizeAction(NULL),
+ m_extractAudioAction(NULL),
m_transcodeAction(NULL),
+ m_stabilizeAction(NULL),
m_doc(NULL),
m_refreshed(false),
m_allClipsProcessed(false),
// small info button for pending jobs
m_infoLabel = new SmallInfoLabel(this);
+ m_infoLabel->setStyleSheet(SmallInfoLabel::getStyleSheet(palette()));
connect(this, SIGNAL(jobCount(int)), m_infoLabel, SLOT(slotSetJobCount(int)));
m_jobsMenu = new QMenu(this);
+ connect(m_jobsMenu, SIGNAL(aboutToShow()), this, SLOT(slotPrepareJobsMenu()));
QAction *cancelJobs = new QAction(i18n("Cancel All Jobs"), this);
cancelJobs->setCheckable(false);
connect(cancelJobs, SIGNAL(triggered()), this, SLOT(slotCancelJobs()));
+ connect(this, SIGNAL(checkJobProcess()), this, SLOT(slotCheckJobProcess()));
+ m_discardCurrentClipJobs = new QAction(i18n("Cancel Current Clip Jobs"), this);
+ m_discardCurrentClipJobs->setCheckable(false);
+ connect(m_discardCurrentClipJobs, SIGNAL(triggered()), this, SLOT(slotDiscardClipJobs()));
m_jobsMenu->addAction(cancelJobs);
+ m_jobsMenu->addAction(m_discardCurrentClipJobs);
m_infoLabel->setMenu(m_jobsMenu);
box->addWidget(m_infoLabel);
-
+
int size = style()->pixelMetric(QStyle::PM_SmallIconSize);
QSize iconSize(size, size);
frame->setLayout(box);
layout->addWidget(frame);
- m_listView = new ProjectListView;
+ m_listView = new ProjectListView(this);
layout->addWidget(m_listView);
+
+#if KDE_IS_VERSION(4,7,0)
+ m_infoMessage = new MyMessageWidget;
+ layout->addWidget(m_infoMessage);
+ m_infoMessage->setCloseButtonVisible(true);
+ connect(m_infoMessage, SIGNAL(messageClosing()), this, SLOT(slotResetInfoMessage()));
+ //m_infoMessage->setWordWrap(true);
+ m_infoMessage->hide();
+ m_logAction = new QAction(i18n("Show Log"), this);
+ m_logAction->setCheckable(false);
+ connect(m_logAction, SIGNAL(triggered()), this, SLOT(slotShowJobLog()));
+#endif
+
setLayout(layout);
searchView->setTreeWidget(m_listView);
connect(this, SIGNAL(processNextThumbnail()), this, SLOT(slotProcessNextThumbnail()));
connect(m_listView, SIGNAL(projectModified()), this, SIGNAL(projectModified()));
connect(m_listView, SIGNAL(itemSelectionChanged()), this, SLOT(slotClipSelected()));
- connect(m_listView, SIGNAL(focusMonitor()), this, SIGNAL(raiseClipMonitor()));
- connect(m_listView, SIGNAL(pauseMonitor()), this, SLOT(slotPauseMonitor()));
+ connect(m_listView, SIGNAL(focusMonitor(bool)), this, SIGNAL(raiseClipMonitor(bool)));
+ connect(m_listView, SIGNAL(pauseMonitor()), this, SIGNAL(pauseMonitor()));
connect(m_listView, SIGNAL(requestMenu(const QPoint &, QTreeWidgetItem *)), this, SLOT(slotContextMenu(const QPoint &, QTreeWidgetItem *)));
+ connect(m_listView, SIGNAL(addClip()), this, SIGNAL(pauseMonitor()));
connect(m_listView, SIGNAL(addClip()), this, SLOT(slotAddClip()));
connect(m_listView, SIGNAL(addClip(const QList <QUrl>, const QString &, const QString &)), this, SLOT(slotAddClip(const QList <QUrl>, const QString &, const QString &)));
+ connect(this, SIGNAL(addClip(const QString, const QString &, const QString &)), this, SLOT(slotAddClip(const QString, const QString &, const QString &)));
connect(m_listView, SIGNAL(addClipCut(const QString &, int, int)), this, SLOT(slotAddClipCut(const QString &, int, int)));
connect(m_listView, SIGNAL(itemChanged(QTreeWidgetItem *, int)), this, SLOT(slotItemEdited(QTreeWidgetItem *, int)));
connect(m_listView, SIGNAL(showProperties(DocClipBase *)), this, SIGNAL(showClipProperties(DocClipBase *)));
connect(this, SIGNAL(cancelRunningJob(const QString, stringMap )), this, SLOT(slotCancelRunningJob(const QString, stringMap)));
-
+ connect(this, SIGNAL(processLog(const QString, int , int, const QString)), this, SLOT(slotProcessLog(const QString, int , int, const QString)));
+
+ connect(this, SIGNAL(updateJobStatus(const QString, int, int, const QString, const QString, const QString)), this, SLOT(slotUpdateJobStatus(const QString, int, int, const QString, const QString, const QString)));
+
+ connect(this, SIGNAL(gotProxy(const QString)), this, SLOT(slotGotProxyForId(const QString)));
+
m_listViewDelegate = new ItemDelegate(m_listView);
m_listView->setItemDelegate(m_listViewDelegate);
-#ifdef NEPOMUK
+#ifdef USE_NEPOMUK
if (KdenliveSettings::activate_nepomuk()) {
Nepomuk::ResourceManager::instance()->init();
if (!Nepomuk::ResourceManager::instance()->initialized()) {
ProjectList::~ProjectList()
{
m_abortAllJobs = true;
+ for (int i = 0; i < m_jobList.count(); i++) {
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
m_closing = true;
m_thumbnailQueue.clear();
+ m_jobThreads.waitForFinished();
+ m_jobThreads.clearFutures();
if (!m_jobList.isEmpty()) qDeleteAll(m_jobList);
m_jobList.clear();
delete m_menu;
m_listView->blockSignals(true);
m_listView->clear();
delete m_listViewDelegate;
+#if KDE_IS_VERSION(4,7,0)
+ delete m_infoMessage;
+#endif
}
void ProjectList::focusTree() const
QMenu* addMenu=menus.value("addMenu");
menu->addMenu(addMenu);
m_addButton->setMenu(menu);
-
- m_menu->addMenu(addMenu);
if (addMenu->isEmpty())
addMenu->setEnabled(false);
}
- if (menus.contains("transcodeMenu") && menus.value("transcodeMenu") ){
- QMenu* transcodeMenu=menus.value("transcodeMenu");
- m_menu->addMenu(transcodeMenu);
- if (transcodeMenu->isEmpty())
- transcodeMenu->setEnabled(false);
- m_transcodeAction = transcodeMenu;
+ if (menus.contains("extractAudioMenu") && menus.value("extractAudioMenu") ){
+ QMenu* extractAudioMenu = menus.value("extractAudioMenu");
+ m_menu->addMenu(extractAudioMenu);
+ m_extractAudioAction = extractAudioMenu;
}
- if (menus.contains("stabilizeMenu") && menus.value("stabilizeMenu") ){
- QMenu* stabilizeMenu=menus.value("stabilizeMenu");
+ if (menus.contains("transcodeMenu") && menus.value("transcodeMenu") ){
+ QMenu* transcodeMenu = menus.value("transcodeMenu");
+ m_menu->addMenu(transcodeMenu);
+ if (transcodeMenu->isEmpty())
+ transcodeMenu->setEnabled(false);
+ m_transcodeAction = transcodeMenu;
+ }
+ if (menus.contains("clipActionsMenu") && menus.value("clipActionsMenu") ){
+ QMenu* stabilizeMenu=menus.value("clipActionsMenu");
m_menu->addMenu(stabilizeMenu);
if (stabilizeMenu->isEmpty())
stabilizeMenu->setEnabled(false);
if (clip->getProperty("transparency").isEmpty() || clip->getProperty("transparency").toInt() == 0) {
if (transparency == "-") {
// first non transparent image
- transparency = "0";
+ transparency = '0';
}
else if (transparency == "1") {
// we have transparent and non transparent clips
else {
if (transparency == "-") {
// first transparent image
- transparency = "1";
+ transparency = '1';
}
else if (transparency == "0") {
// we have transparent and non transparent clips
p.next();
kDebug() << "Result: " << p.key() << " = " << p.value();
}*/
- emit showClipProperties(clipList, commonproperties);
+ if (clipList.isEmpty()) {
+ emit displayMessage(i18n("No available clip selected"), -2, ErrorMessage);
+ }
+ else emit showClipProperties(clipList, commonproperties);
}
void ProjectList::slotOpenClip()
continue;
}
item = static_cast <ProjectItem *>(selected.at(i));
- if (item && !item->isProxyRunning()) {
+ if (item && !hasPendingJob(item, PROXYJOB)) {
DocClipBase *clip = item->referencedClip();
if (!clip || !clip->isClean() || m_render->isProcessing(item->clipId())) {
kDebug()<<"//// TRYING TO RELOAD: "<<item->clipId()<<", but it is busy";
item->referencedClip()->setPlaceHolder(true);
item->setProperty("file_hash", QString());
} else if (t == IMAGE) {
- clip->getProducer()->set("force_reload", 1);
+ //clip->getProducer() clip->getProducer()->set("force_reload", 1);
}
QDomElement e = item->toXml();
} else {
pixmap = KIcon("view-refresh").pixmap(m_listView->iconSize());
}
- item->setData(0, Qt::DecorationRole, pixmap);
+ item->setPixmap(pixmap);
}
}
if (item) {
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
int height = m_listView->iconSize().height();
+ if (m_render == NULL) {
+ kDebug() << "********* ERROR, NULL RENDR";
+ return;
+ }
int width = (int)(height * m_render->dar());
QPixmap pixmap = qVariantValue<QPixmap>(item->data(0, Qt::DecorationRole));
if (pixmap.isNull()) {
QPainter p(&pixmap);
p.drawPixmap(3, 3, icon.pixmap(width - 6, height - 6));
p.end();
- item->setData(0, Qt::DecorationRole, pixmap);
+ item->setPixmap(pixmap);
if (item->referencedClip()) {
item->referencedClip()->setPlaceHolder(true);
- if (m_render == NULL) {
- kDebug() << "********* ERROR, NULL RENDR";
- return;
- }
Mlt::Producer *newProd = m_render->invalidProducer(id);
if (item->referencedClip()->getProducer()) {
Mlt::Properties props(newProd->get_properties());
}
}
update();
- emit displayMessage(i18n("Check missing clips"), -2);
+ emit displayMessage(i18n("Check missing clips"), -2, ErrorMessage);
emit updateRenderStatus();
}
{
m_render = projectRender;
m_listView->setIconSize(QSize((ProjectItem::itemDefaultHeight() - 2) * m_render->dar(), ProjectItem::itemDefaultHeight() - 2));
+ connect(m_render, SIGNAL(requestProxy(QString)), this, SLOT(slotCreateProxy(QString)));
}
void ProjectList::slotClipSelected()
m_deleteButton->defaultAction()->setEnabled(true);
m_openAction->setEnabled(false);
m_reloadAction->setEnabled(false);
+ m_extractAudioAction->setEnabled(false);
m_transcodeAction->setEnabled(false);
m_stabilizeAction->setEnabled(false);
} else {
if (clip == NULL) kDebug() << "-----------ERROR";
SubProjectItem *sub = static_cast <SubProjectItem*>(item);
emit clipSelected(clip->referencedClip(), sub->zone());
+ m_extractAudioAction->setEnabled(false);
m_transcodeAction->setEnabled(false);
m_stabilizeAction->setEnabled(false);
m_reloadAction->setEnabled(false);
m_editButton->defaultAction()->setEnabled(true);
m_deleteButton->defaultAction()->setEnabled(true);
m_reloadAction->setEnabled(true);
+ m_extractAudioAction->setEnabled(true);
m_transcodeAction->setEnabled(true);
m_stabilizeAction->setEnabled(true);
if (clip && clip->clipType() == IMAGE && !KdenliveSettings::defaultimageapp().isEmpty()) {
m_deleteButton->defaultAction()->setEnabled(false);
m_openAction->setEnabled(false);
m_reloadAction->setEnabled(false);
+ m_extractAudioAction->setEnabled(true);
m_transcodeAction->setEnabled(false);
m_stabilizeAction->setEnabled(false);
}
m_proxyAction->setEnabled(false);
return;
}
- m_proxyAction->setEnabled(useProxy());
+ bool enabled = useProxy();
+ if (clip->referencedClip() && !clip->referencedClip()->getProperty("_missingsource").isEmpty()) enabled = false;
+ m_proxyAction->setEnabled(enabled);
m_proxyAction->blockSignals(true);
m_proxyAction->setChecked(clip->hasProxy());
m_proxyAction->blockSignals(false);
void ProjectList::adjustStabilizeActions(ProjectItem *clip) const
{
- if (clip == NULL || clip->type() != PROJECTCLIPTYPE || clip->clipType() == COLOR || clip->clipType() == TEXT || clip->clipType() == PLAYLIST || clip->clipType() == SLIDESHOW) {
+ if (clip == NULL || clip->type() != PROJECTCLIPTYPE || clip->clipType() == COLOR || clip->clipType() == TEXT || clip->clipType() == SLIDESHOW) {
m_stabilizeAction->setEnabled(false);
return;
}
{
if (clip == NULL || clip->type() != PROJECTCLIPTYPE || clip->clipType() == COLOR || clip->clipType() == TEXT || clip->clipType() == PLAYLIST || clip->clipType() == SLIDESHOW) {
m_transcodeAction->setEnabled(false);
+ m_extractAudioAction->setEnabled(false);
return;
}
m_transcodeAction->setEnabled(true);
+ m_extractAudioAction->setEnabled(true);
QList<QAction *> transcodeActions = m_transcodeAction->actions();
QStringList data;
QString condition;
ProjectItem *item = getItemById(id);
if (item) {
slotUpdateClipProperties(item, properties);
- if (properties.contains("out") || properties.contains("force_fps") || properties.contains("resource")) {
+ if (properties.contains("out") || properties.contains("force_fps") || properties.contains("resource") || properties.contains("video_index") || properties.contains("audio_index") || properties.contains("full_luma")) {
slotReloadClip(id);
} else if (properties.contains("colour") ||
properties.contains("xmldata") ||
properties.contains("templatetext")) {
slotRefreshClipThumbnail(item);
emit refreshClip(id, true);
- } else if (properties.contains("full_luma") || properties.contains("force_colorspace") || properties.contains("loop")) {
+ } else if (properties.contains("force_colorspace") || properties.contains("loop")) {
emit refreshClip(id, false);
}
}
clip->setProperties(properties);
if (properties.contains("proxy")) {
if (properties.value("proxy") == "-" || properties.value("proxy").isEmpty())
- clip->setProxyStatus(NOJOB);
+ // this should only apply to proxy jobs
+ clip->setConditionalJobStatus(NOJOB, PROXYJOB);
}
if (properties.contains("name")) {
monitorItemEditing(false);
monitorItemEditing(false);
clip->setText(1, properties.value("description"));
monitorItemEditing(true);
-#ifdef NEPOMUK
+#ifdef USE_NEPOMUK
if (KdenliveSettings::activate_nepomuk() && (type == AUDIO || type == VIDEO || type == AV || type == IMAGE || type == PLAYLIST)) {
// Use Nepomuk system to store clip description
Nepomuk::Resource f(clip->clipUrl().path());
emit projectModified();
EditClipCommand *command = new EditClipCommand(this, clip->clipId(), oldprops, newprops, false);
m_commandStack->push(command);
+ QTimer::singleShot(100, this, SLOT(slotCheckScrolling()));
}
}
}
}
+void ProjectList::slotCheckScrolling()
+{
+ m_listView->scrollToItem(m_listView->currentItem());
+}
+
void ProjectList::slotContextMenu(const QPoint &pos, QTreeWidgetItem *item)
{
bool enable = item ? true : false;
m_editButton->defaultAction()->setEnabled(enable);
m_deleteButton->defaultAction()->setEnabled(enable);
m_reloadAction->setEnabled(enable);
+ m_extractAudioAction->setEnabled(enable);
m_transcodeAction->setEnabled(enable);
m_stabilizeAction->setEnabled(enable);
if (enable) {
ProjectItem *clip = NULL;
if (m_listView->currentItem()->type() == PROJECTSUBCLIPTYPE) {
clip = static_cast <ProjectItem*>(item->parent());
+ m_extractAudioAction->setEnabled(false);
m_transcodeAction->setEnabled(false);
m_stabilizeAction->setEnabled(false);
adjustProxyActions(clip);
// Display uses in timeline
emit findInTimeline(clip->clipId());
} else {
+ m_extractAudioAction->setEnabled(false);
m_transcodeAction->setEnabled(false);
m_stabilizeAction->setEnabled(false);
}
} else {
ProjectItem *item = static_cast <ProjectItem *>(selected.at(i));
ids << item->clipId();
- if (item->numReferences() > 0 && KMessageBox::questionYesNo(kapp->activeWindow(), i18np("Delete clip <b>%2</b>?<br />This will also remove the clip in timeline", "Delete clip <b>%2</b>?<br />This will also remove its %1 clips in timeline", item->numReferences(), item->names().at(1)), i18n("Delete Clip"), KStandardGuiItem::yes(), KStandardGuiItem::no(), "DeleteAll") == KMessageBox::No) {
+ if (item->numReferences() > 0 && KMessageBox::questionYesNo(kapp->activeWindow(), i18np("Delete clip <b>%2</b>?<br />This will also remove the clip in timeline", "Delete clip <b>%2</b>?<br />This will also remove its %1 clips in timeline", item->numReferences(), item->text(1)), i18n("Delete Clip"), KStandardGuiItem::yes(), KStandardGuiItem::no(), "DeleteAll") == KMessageBox::No) {
KMessageBox::enableMessage("DeleteAll");
return;
}
kDebug() << "/// Cannot find clip to delete";
return;
}
- if (item->isProxyRunning()) m_abortProxy.append(item->referencedClip()->getProperty("proxy"));
+ deleteJobsForClip(clipId);
m_listView->blockSignals(true);
QTreeWidgetItem *newSelectedItem = m_listView->itemAbove(item);
if (!newSelectedItem)
m_doc->setModified(true);
}
-void ProjectList::slotAddFolder()
+void ProjectList::slotAddFolder(const QString &name)
{
- AddFolderCommand *command = new AddFolderCommand(this, i18n("Folder"), QString::number(m_doc->clipManager()->getFreeFolderId()), true);
+ AddFolderCommand *command = new AddFolderCommand(this, name.isEmpty() ? i18n("Folder") : name, QString::number(m_doc->clipManager()->getFreeFolderId()), true);
m_commandStack->push(command);
}
{
//m_listView->setEnabled(false);
const QString parent = clip->getProperty("groupid");
+ QString groupName = clip->getProperty("groupname");
+ QSize pixelSize((int)(m_listView->iconSize().height() * m_render->dar()), m_listView->iconSize().height());
ProjectItem *item = NULL;
monitorItemEditing(false);
if (!parent.isEmpty()) {
FolderProjectItem *parentitem = getFolderItemById(parent);
if (!parentitem) {
QStringList text;
- QString groupName = clip->getProperty("groupname");
//kDebug() << "Adding clip to new group: " << groupName;
if (groupName.isEmpty()) groupName = i18n("Folder");
text << groupName;
}
if (parentitem)
- item = new ProjectItem(parentitem, clip);
+ item = new ProjectItem(parentitem, clip, pixelSize);
}
if (item == NULL) {
- item = new ProjectItem(m_listView, clip);
+ item = new ProjectItem(m_listView, clip, pixelSize);
}
if (item->data(0, DurationRole).isNull()) item->setData(0, DurationRole, i18n("Loading"));
connect(clip, SIGNAL(createProxy(const QString &)), this, SLOT(slotCreateProxy(const QString &)));
connect(clip, SIGNAL(abortProxy(const QString &, const QString &)), this, SLOT(slotAbortProxy(const QString, const QString)));
+
if (getProperties) {
- int height = m_listView->iconSize().height();
- int width = (int)(height * m_render->dar());
- QPixmap pix = KIcon("video-x-generic").pixmap(QSize(width, height));
- item->setData(0, Qt::DecorationRole, pix);
//item->setFlags(Qt::ItemIsSelectable);
m_listView->processLayout();
QDomElement e = clip->toXML().cloneNode().toElement();
+ if (!groupName.isEmpty()) {
+ e.setAttribute("groupId", parent);
+ e.setAttribute("group", groupName);
+ }
e.removeAttribute("file_hash");
resetThumbsProducer(clip);
m_render->getFileProperties(e, clip->getId(), m_listView->iconSize().height(), true);
}
// WARNING: code below triggers unnecessary reload of all proxy clips on document loading... is it useful in some cases?
- /*else if (item->hasProxy() && !item->isProxyRunning()) {
+ /*else if (item->hasProxy() && !item->isJobRunning()) {
slotCreateProxy(clip->getId());
}*/
KUrl url = clip->fileURL();
-#ifdef NEPOMUK
- if (!url.isEmpty() && KdenliveSettings::activate_nepomuk()) {
+#ifdef USE_NEPOMUK
+ if (!url.isEmpty() && KdenliveSettings::activate_nepomuk() && clip->getProperty("description").isEmpty()) {
// if file has Nepomuk comment, use it
Nepomuk::Resource f(url.path());
QString annotation = f.description();
- if (!annotation.isEmpty()) item->setText(1, annotation);
+ if (!annotation.isEmpty()) {
+ item->setText(1, annotation);
+ clip->setProperty("description", annotation);
+ }
item->setText(2, QString::number(f.rating()));
}
#endif
QList <CutZoneInfo> cuts = clip->cutZones();
if (!cuts.isEmpty()) {
for (int i = 0; i < cuts.count(); i++) {
- SubProjectItem *sub = new SubProjectItem(item, cuts.at(i).zone.x(), cuts.at(i).zone.y(), cuts.at(i).description);
+ SubProjectItem *sub = new SubProjectItem(m_render->dar(), item, cuts.at(i).zone.x(), cuts.at(i).zone.y(), cuts.at(i).description);
if (!clip->getClipHash().isEmpty()) {
QString cachedPixmap = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "thumbs/" + clip->getClipHash() + '#' + QString::number(cuts.at(i).zone.x()) + ".png";
if (QFile::exists(cachedPixmap)) {
QTreeWidgetItemIterator it(m_listView);
ProjectItem *item;
- while (*it && !m_abortAllJobs) {
+ while (*it && !m_closing) {
if ((*it)->type() == PROJECTCLIPTYPE) {
item = static_cast <ProjectItem *>(*it);
if (item->referencedClip()->getProperty("proxy") == proxyPath)
}
}
+void ProjectList::slotGotProxyForId(const QString id)
+{
+ if (m_closing) return;
+ ProjectItem *item = getItemById(id);
+ slotGotProxy(item);
+}
+
void ProjectList::slotGotProxy(ProjectItem *item)
{
if (item == NULL) return;
{
m_listView->blockSignals(true);
m_abortAllJobs = true;
+ for (int i = 0; i < m_jobList.count(); i++) {
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
m_closing = true;
- m_proxyThreads.waitForFinished();
- m_proxyThreads.clearFutures();
+ m_jobThreads.waitForFinished();
+ m_jobThreads.clearFutures();
m_thumbnailQueue.clear();
if (!m_jobList.isEmpty()) qDeleteAll(m_jobList);
m_jobList.clear();
requestClipThumbnail(item->clipId());
}
else {
- processThumbOverlays(item, pix);
- item->setData(0, Qt::DecorationRole, pix);
+ QPixmap result = roundedPixmap(pix);
+ processThumbOverlays(item, result);
+ item->setPixmap(result);
}
}
else {
}
}
+QPixmap ProjectList::roundedPixmap(QImage img)
+{
+ QPixmap pix(img.width(), img.height());
+ pix.fill(Qt::transparent);
+ QPainter p(&pix);
+ p.setRenderHint(QPainter::Antialiasing, true);
+ QPainterPath path;
+ path.addRoundedRect(0.5, 0.5, pix.width() - 1, pix.height() - 1, 2, 2);
+ p.setClipPath(path);
+ p.drawImage(0, 0, img);
+ p.end();
+ return pix;
+}
+
+QPixmap ProjectList::roundedPixmap(QPixmap source)
+{
+ QPixmap pix(source.width(), source.height());
+ pix.fill(Qt::transparent);
+ QPainter p(&pix);
+ p.setRenderHint(QPainter::Antialiasing, true);
+ QPainterPath path;
+ path.addRoundedRect(0.5, 0.5, pix.width() - 1, pix.height() - 1, 2, 2);
+ p.setClipPath(path);
+ p.drawPixmap(0, 0, source);
+ p.end();
+ return pix;
+}
+
void ProjectList::getCachedThumbnail(SubProjectItem *item)
{
if (!item) return;
DocClipBase *clip = parentItem->referencedClip();
if (!clip) return;
int pos = item->zone().x();
- QString cachedPixmap = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "thumbs/" + clip->getClipHash() + "#" + QString::number(pos) + ".png";
+ QString cachedPixmap = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "thumbs/" + clip->getClipHash() + '#' + QString::number(pos) + ".png";
if (QFile::exists(cachedPixmap)) {
QPixmap pix(cachedPixmap);
if (pix.isNull()) {
} else {
item = static_cast <ProjectItem *>(*it);
clip = item->referencedClip();
- if (item->referencedClip()->getProducer() == NULL) {
+ if (clip->getProducer() == NULL) {
bool replace = false;
if (brokenClips.contains(item->clipId())) {
// if this is a proxy clip, disable proxy
- item->setProxyStatus(NOJOB);
+ item->setConditionalJobStatus(NOJOB, PROXYJOB);
+ discardJobs(item->clipId(), PROXYJOB);
clip->setProperty("proxy", "-");
replace = true;
}
- if (clip->isPlaceHolder() == false && !item->isProxyRunning()) {
+ if (clip->isPlaceHolder() == false && !hasPendingJob(item, PROXYJOB)) {
QDomElement xml = clip->toXML();
if (fpsChanged) {
xml.removeAttribute("out");
xml.removeAttribute("file_hash");
xml.removeAttribute("proxy_out");
}
- if (!replace) replace = xml.attribute("replace") == "1";
+ if (!replace) replace = xml.attribute("_replaceproxy") == "1";
+ xml.removeAttribute("_replaceproxy");
if (replace) {
resetThumbsProducer(clip);
}
}
else if (clip->isPlaceHolder()) {
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
- if (item->data(0, Qt::DecorationRole).isNull()) {
- item->setData(0, Qt::DecorationRole, missingPixmap);
+ if (!item->hasPixmap()) {
+ item->setPixmap(missingPixmap);
}
else {
QPixmap pixmap = qVariantValue<QPixmap>(item->data(0, Qt::DecorationRole));
QPainter p(&pixmap);
p.drawPixmap(3, 3, KIcon("dialog-close").pixmap(pixmap.width() - 6, pixmap.height() - 6));
p.end();
- item->setData(0, Qt::DecorationRole, pixmap);
+ item->setPixmap(pixmap);
}
}
} else {
if (displayRatioChanged) {
requestClipThumbnail(clip->getId());
}
- else if (item->data(0, Qt::DecorationRole).isNull()) {
+ else if (!item->hasPixmap()) {
getCachedThumbnail(item);
}
if (item->data(0, DurationRole).toString().isEmpty()) {
- item->changeDuration(item->referencedClip()->getProducer()->get_playtime());
+ item->changeDuration(clip->getProducer()->get_playtime());
}
if (clip->isPlaceHolder()) {
QPixmap pixmap = qVariantValue<QPixmap>(item->data(0, Qt::DecorationRole));
QPainter p(&pixmap);
p.drawPixmap(3, 3, KIcon("dialog-close").pixmap(pixmap.width() - 6, pixmap.height() - 6));
p.end();
- item->setData(0, Qt::DecorationRole, pixmap);
+ item->setPixmap(pixmap);
+ }
+ else if (clip->getProperty("_replaceproxy") == "1") {
+ clip->setProperty("_replaceproxy", QString());
+ slotCreateProxy(clip->getId());
}
}
item->setData(0, UsageRole, QString::number(item->numReferences()));
QString ProjectList::getExtensions()
{
// Build list of mime types
- QStringList mimeTypes = QStringList() << "application/x-kdenlive" << "application/x-kdenlivetitle" << "video/mlt-playlist" << "text/plain"
- << "video/x-flv" << "application/vnd.rn-realmedia" << "video/x-dv" << "video/dv" << "video/x-msvideo" << "video/x-matroska" << "video/mpeg" << "video/ogg" << "video/x-ms-wmv" << "video/mp4" << "video/quicktime" << "video/webm"
- << "audio/x-flac" << "audio/x-matroska" << "audio/mp4" << "audio/mpeg" << "audio/x-mp3" << "audio/ogg" << "audio/x-wav" << "audio/x-aiff" << "audio/aiff" << "application/ogg" << "application/mxf" << "application/x-shockwave-flash"
- << "image/gif" << "image/jpeg" << "image/png" << "image/x-tga" << "image/x-bmp" << "image/svg+xml" << "image/tiff" << "image/x-xcf" << "image/x-xcf-gimp" << "image/x-vnd.adobe.photoshop" << "image/x-pcx" << "image/x-exr";
+ QStringList mimeTypes = QStringList() << "application/x-kdenlive" << "application/x-kdenlivetitle" << "video/mlt-playlist" << "text/plain";
+
+ // Video mimes
+ mimeTypes << "video/x-flv" << "application/vnd.rn-realmedia" << "video/x-dv" << "video/dv" << "video/x-msvideo" << "video/x-matroska" << "video/mpeg" << "video/ogg" << "video/x-ms-wmv" << "video/mp4" << "video/quicktime" << "video/webm" << "video/3gpp" << "video/mp2t";
+
+ // Audio mimes
+ mimeTypes << "audio/x-flac" << "audio/x-matroska" << "audio/mp4" << "audio/mpeg" << "audio/x-mp3" << "audio/ogg" << "audio/x-wav" << "audio/x-aiff" << "audio/aiff" << "application/ogg" << "application/mxf" << "application/x-shockwave-flash" << "audio/ac3";
+
+ // Image mimes
+ mimeTypes << "image/gif" << "image/jpeg" << "image/png" << "image/x-tga" << "image/x-bmp" << "image/svg+xml" << "image/tiff" << "image/x-xcf" << "image/x-xcf-gimp" << "image/x-vnd.adobe.photoshop" << "image/x-pcx" << "image/x-exr";
QString allExtensions;
foreach(const QString & mimeType, mimeTypes) {
return allExtensions.simplified();
}
+void ProjectList::slotAddClip(const QString url, const QString &groupName, const QString &groupId)
+{
+ kDebug()<<"// Adding clip: "<<url;
+ QList <QUrl> list;
+ list.append(url);
+ slotAddClip(list, groupName, groupId);
+}
+
void ProjectList::slotAddClip(const QList <QUrl> givenList, const QString &groupName, const QString &groupId)
{
if (!m_commandStack)
l->addWidget(c);
l->addStretch(5);
f->setLayout(l);
- KFileDialog *d = new KFileDialog(KUrl("kfiledialog:///clipfolder"), dialogFilter, kapp->activeWindow(), f);
+ QPointer<KFileDialog> d = new KFileDialog(KUrl("kfiledialog:///clipfolder"), dialogFilter, kapp->activeWindow(), f);
d->setOperationMode(KFileDialog::Opening);
d->setMode(KFile::Files);
if (d->exec() == QDialog::Accepted) {
while (fileName.at(fileName.size() - 1).isDigit()) {
fileName.chop(1);
}
-
- m_doc->slotCreateSlideshowClipFile(fileName, pattern, count, m_timecode.reformatSeparators(KdenliveSettings::sequence_duration()),
- false, false, false,
- m_timecode.getTimecodeFromFrames(int(ceil(m_timecode.fps()))), QString(), 0,
- QString(), groupInfo.at(0), groupInfo.at(1));
+ 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", QString::number(m_doc->getFramePos(m_timecode.getTimecodeFromFrames(int(ceil(m_timecode.fps()))))));
+ m_doc->slotCreateSlideshowClipFile(properties, groupInfo.at(0), groupInfo.at(1));
return;
}
}
for (int i = 0; i < givenList.count(); i++)
list << givenList.at(i);
}
+ QList <KUrl::List> foldersList;
foreach(const KUrl & file, list) {
// Check there is no folder here
KMimeType::Ptr type = KMimeType::findByUrl(file);
if (type->is("inode/directory")) {
- // user dropped a folder
+ // user dropped a folder, import its files
list.removeAll(file);
+ QDir dir(file.path());
+ QStringList result = dir.entryList(QDir::Files);
+ KUrl::List folderFiles;
+ folderFiles << file;
+ foreach(const QString & path, result) {
+ KUrl newFile = file;
+ newFile.addPath(path);
+ folderFiles.append(newFile);
+ }
+ if (folderFiles.count() > 1) foldersList.append(folderFiles);
}
}
- if (list.isEmpty())
- return;
-
- if (givenList.isEmpty()) {
+ if (givenList.isEmpty() && !list.isEmpty()) {
QStringList groupInfo = getGroup();
- m_doc->slotAddClipList(list, groupInfo.at(0), groupInfo.at(1));
- } else {
- m_doc->slotAddClipList(list, groupName, groupId);
+ QMap <QString, QString> data;
+ data.insert("group", groupInfo.at(0));
+ data.insert("groupId", groupInfo.at(1));
+ m_doc->slotAddClipList(list, data);
+ } else if (!list.isEmpty()) {
+ QMap <QString, QString> data;
+ data.insert("group", groupName);
+ data.insert("groupId", groupId);
+ m_doc->slotAddClipList(list, data);
+ }
+
+ if (!foldersList.isEmpty()) {
+ // create folders
+ for (int i = 0; i < foldersList.count(); i++) {
+ KUrl::List urls = foldersList.at(i);
+ KUrl folderUrl = urls.takeFirst();
+ QString folderName = folderUrl.fileName();
+ FolderProjectItem *folder = NULL;
+ if (!folderName.isEmpty()) {
+ folder = getFolderItemByName(folderName);
+ if (folder == NULL) {
+ slotAddFolder(folderName);
+ folder = getFolderItemByName(folderName);
+ }
+ }
+ if (folder) {
+ QMap <QString, QString> data;
+ data.insert("group", folder->groupName());
+ data.insert("groupId", folder->clipId());
+ m_doc->slotAddClipList(urls, data);
+ }
+ else m_doc->slotAddClipList(urls);
+ }
}
}
void ProjectList::slotRemoveInvalidClip(const QString &id, bool replace)
{
ProjectItem *item = getItemById(id);
- m_processingClips.removeAll(id);
m_thumbnailQueue.removeAll(id);
if (item) {
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsDropEnabled);
if (durationError) {
kDebug() << "Proxy duration is wrong, try changing transcoding parameters.";
- emit displayMessage(i18n("Proxy clip unusable (duration is different from original)."), -2);
+ emit displayMessage(i18n("Proxy clip unusable (duration is different from original)."), -2, ErrorMessage);
}
- item->setProxyStatus(JOBCRASHED);
+ slotUpdateJobStatus(item, PROXYJOB, JOBCRASHED, i18n("Failed to create proxy for %1. check parameters", item->text(0)), "project_settings");
QString path = item->referencedClip()->getProperty("proxy");
KUrl proxyFolder(m_doc->projectFolder().path( KUrl::AddTrailingSlash) + "proxy/");
item->referencedClip()->reloadThumbProducer();
}
}
- m_processingClips.removeAll(id);
m_thumbnailQueue.removeAll(id);
}
if (!m_commandStack)
kDebug() << "!!!!!!!!!!!!!!!! NO CMD STK";
- QDialog *dia = new QDialog(this);
+ QPointer<QDialog> dia = new QDialog(this);
Ui::ColorClip_UI dia_ui;
dia_ui.setupUi(dia);
dia->setWindowTitle(i18n("Color Clip"));
if (dia->exec() == QDialog::Accepted) {
QStringList groupInfo = getGroup();
- m_doc->slotCreateSlideshowClipFile(dia->clipName(), dia->selectedPath(), dia->imageCount(), dia->clipDuration(),
- dia->loop(), dia->crop(), dia->fade(),
- dia->lumaDuration(), dia->lumaFile(), dia->softness(),
- dia->animation(), groupInfo.at(0), groupInfo.at(1));
+
+ QMap <QString, QString> properties;
+ properties.insert("name", dia->clipName());
+ properties.insert("resource", dia->selectedPath());
+ properties.insert("in", "0");
+ properties.insert("out", QString::number(m_doc->getFramePos(dia->clipDuration()) * dia->imageCount()));
+ properties.insert("ttl", QString::number(m_doc->getFramePos(dia->clipDuration())));
+ properties.insert("loop", QString::number(dia->loop()));
+ properties.insert("crop", QString::number(dia->crop()));
+ properties.insert("fade", QString::number(dia->fade()));
+ properties.insert("luma_duration", dia->lumaDuration());
+ properties.insert("luma_file", dia->lumaFile());
+ properties.insert("softness", QString::number(dia->softness()));
+ properties.insert("animation", dia->animation());
+
+ m_doc->slotCreateSlideshowClipFile(properties, groupInfo.at(0), groupInfo.at(1));
}
delete dia;
}
const QString path = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "titles/";
QStringList templateFiles = QDir(path).entryList(filter, QDir::Files);
- QDialog *dia = new QDialog(this);
+ QPointer<QDialog> dia = new QDialog(this);
Ui::TemplateClip_UI dia_ui;
dia_ui.setupUi(dia);
for (int i = 0; i < templateFiles.size(); ++i)
{
m_listView->blockSignals(true);
m_abortAllJobs = true;
+ for (int i = 0; i < m_jobList.count(); i++) {
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
m_closing = true;
- m_proxyThreads.waitForFinished();
- m_proxyThreads.clearFutures();
+ m_jobThreads.waitForFinished();
+ m_jobThreads.clearFutures();
m_thumbnailQueue.clear();
m_listView->clear();
- m_processingClips.clear();
m_listView->setSortingEnabled(false);
emit clipSelected(NULL);
connect(m_doc->clipManager(), SIGNAL(missingClip(const QString &)), this, SLOT(slotMissingClip(const QString &)));
connect(m_doc->clipManager(), SIGNAL(availableClip(const QString &)), this, SLOT(slotAvailableClip(const QString &)));
connect(m_doc->clipManager(), SIGNAL(checkAllClips(bool, bool, QStringList)), this, SLOT(updateAllClips(bool, bool, QStringList)));
+ connect(m_doc->clipManager(), SIGNAL(thumbReady(const QString &, int, QImage)), this, SLOT(slotSetThumbnail(const QString &, int, QImage)));
+}
+
+void ProjectList::slotSetThumbnail(const QString &id, int framePos, QImage img)
+{
+ QString fullid = id + '#' + QString::number(framePos);
+ ProjectItem *pItem = NULL;
+ QTreeWidgetItem *item = getAnyItemById(fullid);
+ if (item && item->parent()) pItem = static_cast <ProjectItem *>(item->parent());
+ if (!item && framePos == 0) pItem = getItemById(id);
+ if (!item && !pItem) return;
+ if (item) {
+ if (item->type() == PROJECTCLIPTYPE) static_cast<ProjectItem*>(item)->setPixmap(QPixmap::fromImage(img));
+ else item->setData(0, Qt::DecorationRole, QPixmap::fromImage(img));
+ }
+ else if (pItem) pItem->setPixmap(QPixmap::fromImage(img));
+ if (pItem) {
+ QString hash = pItem->getClipHash();
+ if (!hash.isEmpty()) m_doc->cacheImage(hash + '#' + QString::number(framePos), img);
+ }
}
QList <DocClipBase*> ProjectList::documentClipList() const
slotProcessNextThumbnail();
return;
}
- QPixmap pix;
QImage img;
int height = m_listView->iconSize().height();
int swidth = (int)(height * m_render->frameRenderWidth() / m_render->renderHeight()+ 0.5);
int dwidth = (int)(height * m_render->dar() + 0.5);
- if (clip->clipType() == AUDIO)
- pix = KIcon("audio-x-generic").pixmap(QSize(dwidth, height));
- else if (clip->clipType() == IMAGE)
+ if (clip->clipType() == IMAGE) {
img = KThumb::getFrame(item->referencedClip()->getProducer(), 0, swidth, dwidth, height);
- else {
+ }
+ else if (clip->clipType() != AUDIO) {
img = item->referencedClip()->extractImage(frame, dwidth, height);
}
-
- if (!pix.isNull() || !img.isNull()) {
+ if (!img.isNull()) {
monitorItemEditing(false);
- if (!img.isNull()) {
- pix = QPixmap::fromImage(img);
- processThumbOverlays(item, pix);
- }
- it->setData(0, Qt::DecorationRole, pix);
+ QPixmap pix = roundedPixmap(img);
+ processThumbOverlays(item, pix);
+ if (isSubItem) it->setData(0, Qt::DecorationRole, pix);
+ else item->setPixmap(pix);
monitorItemEditing(true);
QString hash = item->getClipHash();
{
QString toReload;
ProjectItem *item = getItemById(clipId);
-
int queue = m_render->processingItems();
if (item && producer) {
monitorItemEditing(false);
// Proxy stuff
QString size = properties.value("frame_size");
- if (!useProxy() && clip->getProperty("proxy").isEmpty()) setProxyStatus(item, NOJOB);
- if (useProxy() && generateProxy() && clip->getProperty("proxy") == "-") setProxyStatus(item, NOJOB);
- else if (useProxy() && !item->hasProxy() && !item->isProxyRunning()) {
+ if (!useProxy() && clip->getProperty("proxy").isEmpty()) {
+ item->setConditionalJobStatus(NOJOB, PROXYJOB);
+ discardJobs(clipId, PROXYJOB);
+ }
+ if (useProxy() && generateProxy() && clip->getProperty("proxy") == "-") {
+ item->setConditionalJobStatus(NOJOB, PROXYJOB);
+ discardJobs(clipId, PROXYJOB);
+ }
+ else if (useProxy() && !item->hasProxy() && !hasPendingJob(item, PROXYJOB)) {
// proxy video and image clips
int maxSize;
CLIPTYPE t = item->clipType();
if (clip->getProperty("proxy").isEmpty()) {
KUrl proxyPath = m_doc->projectFolder();
proxyPath.addPath("proxy/");
- proxyPath.addPath(clip->getClipHash() + "." + (t == IMAGE ? "png" : m_doc->getDocumentProperty("proxyextension")));
+ proxyPath.addPath(clip->getClipHash() + '.' + (t == IMAGE ? "png" : m_doc->getDocumentProperty("proxyextension")));
QMap <QString, QString> newProps;
// insert required duration for proxy
if (t != IMAGE) newProps.insert("proxy_out", clip->producerProperty("out"));
}
}
- if (!replace && m_allClipsProcessed && item->data(0, Qt::DecorationRole).isNull()) {
+ if (!replace && m_allClipsProcessed && !item->hasPixmap()) {
getCachedThumbnail(item);
}
if (!toReload.isEmpty())
QString size = item->referencedClip()->getProperty("frame_size");
int width = size.section('x', 0, 0).toInt();
int height = size.section('x', -1).toInt();
+ // Fix some avchd clips tht report a wrong size (1920x1088)
+ if (height == 1088) height = 1080;
double fps = item->referencedClip()->getProperty("fps").toDouble();
double par = item->referencedClip()->getProperty("aspect_ratio").toDouble();
if (item->clipType() == IMAGE || item->clipType() == AV || item->clipType() == VIDEO) {
{
ProjectItem *item = getItemById(clipId);
if (item && !img.isNull()) {
- QPixmap pix = QPixmap::fromImage(img);
+ QPixmap pix = roundedPixmap(img);
processThumbOverlays(item, pix);
monitorItemEditing(false);
- item->setData(0, Qt::DecorationRole, pix);
+ item->setPixmap(pix);
monitorItemEditing(true);
QString hash = item->getClipHash();
if (!hash.isEmpty()) m_doc->cacheImage(hash, img);
return NULL;
}
+FolderProjectItem *ProjectList::getFolderItemByName(const QString &name)
+{
+ FolderProjectItem *item = NULL;
+ QList <QTreeWidgetItem *> hits = m_listView->findItems(name, Qt::MatchExactly, 0);
+ for (int i = 0; i < hits.count(); i++) {
+ if (hits.at(i)->type() == PROJECTFOLDERTYPE) {
+ item = static_cast<FolderProjectItem *>(hits.at(i));
+ break;
+ }
+ }
+ return item;
+}
+
FolderProjectItem *ProjectList::getFolderItemById(const QString &id)
{
FolderProjectItem *item;
m_editButton->defaultAction()->setEnabled(true);
m_deleteButton->defaultAction()->setEnabled(true);
m_reloadAction->setEnabled(true);
+ m_extractAudioAction->setEnabled(true);
m_transcodeAction->setEnabled(true);
m_stabilizeAction->setEnabled(true);
if (clip->clipType() == IMAGE && !KdenliveSettings::defaultimageapp().isEmpty()) {
return result;
}
+QStringList ProjectList::getConditionalIds(const QString &condition) const
+{
+ QStringList result;
+ ProjectItem *item;
+ QList<QTreeWidgetItem *> list = m_listView->selectedItems();
+ for (int i = 0; i < list.count(); i++) {
+ if (list.at(i)->type() == PROJECTFOLDERTYPE)
+ continue;
+ if (list.at(i)->type() == PROJECTSUBCLIPTYPE) {
+ // subitem
+ item = static_cast <ProjectItem*>(list.at(i)->parent());
+ } else {
+ item = static_cast <ProjectItem*>(list.at(i));
+ }
+ if (item == NULL || item->type() == COLOR || item->type() == SLIDESHOW || item->type() == TEXT)
+ continue;
+ DocClipBase *clip = item->referencedClip();
+ if (!condition.isEmpty()) {
+ if (condition.startsWith("vcodec") && !clip->hasVideoCodec(condition.section('=', 1, 1)))
+ continue;
+ else if (condition.startsWith("acodec") && !clip->hasAudioCodec(condition.section('=', 1, 1)))
+ continue;
+ }
+ result.append(item->clipId());
+ }
+ return result;
+}
+
void ProjectList::regenerateTemplate(const QString &id)
{
ProjectItem *clip = getItemById(id);
DocClipBase *base = clip->referencedClip();
base->addCutZone(in, out);
monitorItemEditing(false);
- SubProjectItem *sub = new SubProjectItem(clip, in, out, desc);
+ SubProjectItem *sub = new SubProjectItem(m_render->dar(), clip, in, out, desc);
if (newItem && desc.isEmpty() && !m_listView->isColumnHidden(1)) {
if (!clip->isExpanded())
clip->setExpanded(true);
m_listView->scrollToItem(sub);
m_listView->editItem(sub, 1);
}
- QImage img = clip->referencedClip()->extractImage(in, (int)(sub->sizeHint(0).height() * m_render->dar()), sub->sizeHint(0).height() - 2);
- sub->setData(0, Qt::DecorationRole, QPixmap::fromImage(img));
- QString hash = clip->getClipHash();
- if (!hash.isEmpty()) m_doc->cacheImage(hash + '#' + QString::number(in), img);
+ m_doc->clipManager()->requestThumbs(QString('#' + id), QList <int>() << in);
monitorItemEditing(true);
}
emit projectModified();
} else {
// Create sequence
QStringList groupInfo = getGroup();
- m_doc->slotCreateSlideshowClipFile(fileName, pattern, count, m_timecode.reformatSeparators(KdenliveSettings::sequence_duration()),
- false, false, false,
- m_timecode.getTimecodeFromFrames(int(ceil(m_timecode.fps()))), QString(), 0,
- QString(), groupInfo.at(0), groupInfo.at(1));
- }
- } else emit displayMessage(i18n("Sequence not found"), -2);
+ 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, ErrorMessage);
}
QMap <QString, QString> ProjectList::getProxies()
void ProjectList::slotCreateProxy(const QString id)
{
ProjectItem *item = getItemById(id);
- if (!item || item->isProxyRunning() || item->referencedClip()->isPlaceHolder()) return;
+ if (!item || hasPendingJob(item, PROXYJOB) || item->referencedClip()->isPlaceHolder()) return;
QString path = item->referencedClip()->getProperty("proxy");
if (path.isEmpty()) {
- setProxyStatus(item, JOBCRASHED);
- return;
- }
- setProxyStatus(item, JOBWAITING);
- if (m_abortProxy.contains(path)) m_abortProxy.removeAll(path);
- if (m_processingProxy.contains(path)) {
- // Proxy is already being generated
+ slotUpdateJobStatus(item, PROXYJOB, JOBCRASHED, i18n("Failed to create proxy, empty path."));
return;
}
+
if (QFileInfo(path).size() > 0) {
// Proxy already created
- setProxyStatus(item, JOBDONE);
+ setJobStatus(item, PROXYJOB, JOBDONE);
slotGotProxy(path);
return;
}
- m_processingProxy.append(path);
+ QString sourcePath = item->clipUrl().path();
+ if (item->clipType() == PLAYLIST) {
+ // Special case: playlists use the special 'consumer' producer to support resizing
+ sourcePath.prepend("consumer:");
+ }
+ ProxyJob *job = new ProxyJob(item->clipType(), id, QStringList() << path << sourcePath << 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;
+ }
- /*PROXYINFO info;
- info.dest = path;
- info.src = item->clipUrl().path();
- info.type = item->clipType();
- info.exif = QString(item->referencedClip()->producerProperty("_exif_orientation")).toInt();*/
- ProxyJob *job = new ProxyJob(PROXYJOB, item->clipType(), item->clipId(), 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()));
m_jobList.append(job);
- int ct = 0;
- if (!m_proxyThreads.futures().isEmpty()) {
+ 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);
+
+ QPointer<QDialog> d = new QDialog(this);
+ Ui::CutJobDialog_UI ui;
+ ui.setupUi(d);
+ ui.extra_params->setVisible(false);
+ ui.add_clip->setChecked(KdenliveSettings::add_new_clip());
+ 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_new_clip(ui.add_clip->isChecked());
+ delete d;
+
+ QStringList jobParams;
+ jobParams << dest << item->clipUrl().path() << timeIn << timeOut << QString::number(duration) << QString::number(KdenliveSettings::add_new_clip());
+ 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_new_clip());
+ 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_new_clip(ui.add_clip->isChecked());
+ int index = 0;
+ 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 = destinations.at(index);
+ index++;
+ }
+ 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_new_clip());
+ 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_proxyThreads.futures();
- m_proxyThreads.clearFutures();
+ QList <QFuture<void> > futures = m_jobThreads.futures();
+ m_jobThreads.clearFutures();
for (int i = 0; i < futures.count(); i++)
if (!futures.at(i).isFinished()) {
- m_proxyThreads.addFuture(futures.at(i));
- ct++;
+ m_jobThreads.addFuture(futures.at(i));
}
}
- emit jobCount(ct + m_jobList.count());
+ 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)->status() == JOBWORKING || m_jobList.at(i)->status() == JOBWAITING)
+ count ++;
+ else {
+ // remove finished jobs
+ AbstractClipJob *job = m_jobList.takeAt(i);
+ job->deleteLater();
+ i--;
+ }
+ }
+
+ emit jobCount(count);
+ m_jobMutex.unlock();
- if (m_proxyThreads.futures().isEmpty() || m_proxyThreads.futures().count() < KdenliveSettings::proxythreads()) m_proxyThreads.addFuture(QtConcurrent::run(this, &ProjectList::slotGenerateProxy));
+ 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)
{
- QTreeWidgetItemIterator it(m_listView);
+ Q_UNUSED(path)
+
ProjectItem *item = getItemById(id);
if (!item) return;
- if (!path.isEmpty() && m_processingProxy.contains(path)) {
- m_abortProxy << path;
- }
- else {
- // Should only be done if we were already using a proxy producer
- if (!item->isProxyRunning()) slotGotProxy(item);
- }
+ if (!item->isProxyRunning()) slotGotProxy(item);
+ item->setConditionalJobStatus(NOJOB, PROXYJOB);
+ discardJobs(id, PROXYJOB);
}
-void ProjectList::slotGenerateProxy()
+void ProjectList::slotProcessJobs()
{
while (!m_jobList.isEmpty() && !m_abortAllJobs) {
emit projectModified();
- AbstractClipJob *job = m_jobList.takeFirst();
- // Get jobs count
- int ct = 0;
- QList <QFuture<void> > futures = m_proxyThreads.futures();
- for (int i = 0; i < futures.count(); i++)
- if (futures.at(i).isRunning()) {
- ct++;
- }
- emit jobCount(ct + m_jobList.count());
-
- if (job->jobType == PROXYJOB) {
- //ProxyJob *pjob = static_cast<ProxyJob *> (job);
- kDebug()<<"// STARTING JOB: "<<job->destination();
- if (m_abortProxy.contains(job->destination())) {
- m_abortProxy.removeAll(job->destination());
- m_processingProxy.removeAll(job->destination());
- emit cancelRunningJob(job->clipId(), job->cancelProperties());
- delete job;
- continue;
- }
- }
-
- // Get the list of clips that will need to get progress info
- QTreeWidgetItemIterator it(m_listView);
- QList <ProjectItem *> processingItems;
- ProjectItem *item = getItemById(job->clipId());
- processingItems.append(item);
-
- /*while (*it && !m_abortAllJobs) {
- if ((*it)->type() == PROJECTCLIPTYPE) {
- ProjectItem *item = static_cast <ProjectItem *>(*it);
- if (item->referencedClip()->getProperty("proxy") == job->destination()) {
- processingItems.append(item);
+ AbstractClipJob *job = NULL;
+ int count = 0;
+ m_jobMutex.lock();
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->status() == JOBWAITING) {
+ if (job == NULL) {
+ m_jobList.at(i)->setStatus(JOBWORKING);
+ job = m_jobList.at(i);
}
+ count++;
}
- ++it;
- }*/
-
- // Make sure proxy path is writable
- QFile file(job->destination());
- if (!file.open(QIODevice::WriteOnly)) {
- for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), JOBCRASHED);
- m_processingProxy.removeAll(job->destination());
- delete job;
- continue;
+ else if (m_jobList.at(i)->status() == JOBWORKING)
+ count ++;
}
- file.close();
- QFile::remove(job->destination());
-
- for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), CREATINGJOB, 0); //, job->description);
- bool success;
- QProcess *jobProcess = job->startJob(&success);
-
- int result = -1;
- if (jobProcess == NULL) {
- // job is finished
- for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), success ? JOBDONE : JOBCRASHED);
- if (success) {
- slotGotProxy(job->destination());
- }
- else {
- QFile::remove(job->destination());
- }
- m_abortProxy.removeAll(job->destination());
- m_processingProxy.removeAll(job->destination());
- delete job;
+ // 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;
}
- else while (jobProcess->state() != QProcess::NotRunning) {
- // building proxy file
- if (m_abortProxy.contains(job->destination()) || m_abortAllJobs) {
- jobProcess->close();
- jobProcess->waitForFinished();
- QFile::remove(job->destination());
- m_abortProxy.removeAll(job->destination());
- m_processingProxy.removeAll(job->destination());
- if (!m_closing) {
- emit cancelRunningJob(job->clipId(), job->cancelProperties());
- /*for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), NOJOB);*/
- }
- else continue;
- result = -2;
+ // 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;
}
- else {
- int progress = job->processLogInfo();
- if (progress > -1) processLogInfo(processingItems, progress);
+ 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)));
+
+ if (job->jobType == MLTJOB) {
+ MeltJob *jb = static_cast<MeltJob *> (job);
+ jb->setProducer(currentClip->getProducer(), currentClip->fileURL());
+ if (jb->isProjectFilter())
+ connect(job, SIGNAL(gotFilterJobResults(QString,int, int, stringMap,stringMap)), this, SLOT(slotGotFilterJobResults(QString,int, int,stringMap,stringMap)));
+ else
+ connect(job, SIGNAL(gotFilterJobResults(QString,int, int, stringMap,stringMap)), this, SIGNAL(gotFilterJobResults(QString,int, int,stringMap,stringMap)));
+ }
+ job->startJob();
+ if (job->status() == 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());
}
- jobProcess->waitForFinished(500);
+ } else if (job->status() == JOBCRASHED || job->status() == JOBABORTED) {
+ emit updateJobStatus(job->clipId(), job->jobType, job->status(), job->errorMessage(), QString(), job->logDetails());
}
- jobProcess->waitForFinished();
- m_processingProxy.removeAll(job->destination());
- if (result == -1) result = jobProcess->exitStatus();
-
- if (result != -2 && QFileInfo(job->destination()).size() == 0) {
- result = QProcess::CrashExit;
- }
-
- if (result == QProcess::NormalExit) {
- // proxy successfully created
- for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), JOBDONE);
- slotGotProxy(job->destination());
- }
- else if (result == QProcess::CrashExit) {
- // Proxy process crashed
- QFile::remove(job->destination());
- for (int i = 0; i < processingItems.count(); i++)
- setProxyStatus(processingItems.at(i), JOBCRASHED);
- }
- delete job;
- continue;
}
- // Thread finished, update count
- int ct = -1; // -1 because we don't want to count this terminating thread
- QList <QFuture<void> > futures = m_proxyThreads.futures();
- for (int i = 0; i < futures.count(); i++)
- if (futures.at(i).isRunning()) {
- ct++;
- }
- emit jobCount(ct + m_jobList.count());
+ // Thread finished, cleanup & update count
+ QTimer::singleShot(200, this, SIGNAL(checkJobProcess()));
}
-void ProjectList::processLogInfo(QList <ProjectItem *>items, int progress)
-{
- for (int i = 0; i < items.count(); i++)
- setProxyStatus(items.at(i), CREATINGJOB, progress);
-}
-
void ProjectList::updateProxyConfig()
{
ProjectItem *item;
}
CLIPTYPE t = item->clipType();
if ((t == VIDEO || t == AV || t == UNKNOWN) && item->referencedClip() != NULL) {
- if (generateProxy() && useProxy() && !item->isProxyRunning()) {
+ 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()) {
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"));
+ newProps.insert("proxy", proxydir + item->referencedClip()->getClipHash() + '.' + m_doc->getDocumentProperty("proxyextension"));
new EditClipCommand(this, clip->getId(), oldProps, newProps, true, command);
}
}
// remove proxy
QMap <QString, QString> newProps;
newProps.insert("proxy", QString());
- newProps.insert("replace", "1");
// 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);
// remove proxy
QMap <QString, QString> newProps;
newProps.insert("proxy", QString());
- newProps.insert("replace", "1");
new EditClipCommand(this, item->clipId(), item->referencedClip()->properties(), newProps, true, 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;
//oldProps = clip->properties();
if (doProxy) {
newProps.clear();
- QString path = proxydir + clip->getClipHash() + "." + (t == IMAGE ? "png" : m_doc->getDocumentProperty("proxyextension"));
+ 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);
QFile::remove(proxyPath);
}
-void ProjectList::setProxyStatus(ProjectItem *item, CLIPJOBSTATUS status, int progress)
+void ProjectList::setJobStatus(ProjectItem *item, JOBTYPE jobType, CLIPJOBSTATUS status, int progress, const QString &statusMessage)
{
- if (item == NULL || m_abortAllJobs) return;
+ if (item == NULL || (m_abortAllJobs && m_closing)) return;
monitorItemEditing(false);
- item->setProxyStatus(status, progress);
+ item->setJobStatus(jobType, status, progress, statusMessage);
if (status == JOBCRASHED) {
DocClipBase *clip = item->referencedClip();
if (!clip) {
{
if (item->hasProxy()) {
QPainter p(&pix);
- QColor c = QPalette().base().color();
- c.setAlpha(160);
- QBrush br(c);
- p.setBrush(br);
- p.setPen(Qt::NoPen);
- QRect r(1, 1, 10, 10);
- p.drawRect(r);
- p.setPen(QPalette().text().color());
+ QColor c(220, 220, 10, 200);
+ QRect r(0, 0, 12, 12);
+ p.fillRect(r, c);
+ QFont font = p.font();
+ font.setBold(true);
+ p.setFont(font);
+ p.setPen(Qt::black);
p.drawText(r, Qt::AlignCenter, i18nc("The first letter of Proxy, used as abbreviation", "P"));
}
}
void ProjectList::slotCancelJobs()
{
m_abortAllJobs = true;
- m_proxyThreads.waitForFinished();
- m_proxyThreads.clearFutures();
+ for (int i = 0; i < m_jobList.count(); i++) {
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
+ m_jobThreads.waitForFinished();
+ m_jobThreads.clearFutures();
QUndoCommand *command = new QUndoCommand();
command->setText(i18np("Cancel job", "Cancel jobs", m_jobList.count()));
+ m_jobMutex.lock();
for (int i = 0; i < m_jobList.count(); i++) {
- ProjectItem *item = getItemById(m_jobList.at(i)->clipId());
- if (!item || !item->referencedClip()) continue;
+ DocClipBase *currentClip = m_doc->clipManager()->getClipById(m_jobList.at(i)->clipId());
+ if (!currentClip) continue;
QMap <QString, QString> newProps = m_jobList.at(i)->cancelProperties();
if (newProps.isEmpty()) continue;
- QMap <QString, QString> oldProps = item->referencedClip()->currentProperties(newProps);
+ QMap <QString, QString> oldProps = currentClip->currentProperties(newProps);
new EditClipCommand(this, m_jobList.at(i)->clipId(), oldProps, newProps, true, command);
}
+ m_jobMutex.unlock();
if (command->childCount() > 0) {
m_doc->commandStack()->push(command);
}
else delete command;
if (!m_jobList.isEmpty()) qDeleteAll(m_jobList);
- m_processingProxy.clear();
m_jobList.clear();
m_abortAllJobs = false;
m_infoLabel->slotSetJobCount(0);
void ProjectList::slotCancelRunningJob(const QString id, stringMap newProps)
{
- if (newProps.isEmpty()) return;
- ProjectItem *item = getItemById(id);
- if (!item || !item->referencedClip()) return;
- QMap <QString, QString> oldProps = item->referencedClip()->currentProperties(newProps);
+ if (newProps.isEmpty() || m_closing) return;
+ DocClipBase *currentClip = m_doc->clipManager()->getClipById(id);
+ if (!currentClip) return;
+ QMap <QString, QString> oldProps = currentClip->currentProperties(newProps);
if (newProps == oldProps) return;
QMapIterator<QString, QString> i(oldProps);
EditClipCommand *command = new EditClipCommand(this, id, oldProps, newProps, true);
m_commandStack->push(command);
}
+bool ProjectList::hasPendingJob(ProjectItem *item, JOBTYPE type)
+{
+ if (!item || !item->referencedClip() || m_abortAllJobs) return false;
+ AbstractClipJob *job;
+ QMutexLocker lock(&m_jobMutex);
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_abortAllJobs) break;
+ job = m_jobList.at(i);
+ if (job->clipId() == item->clipId() && job->jobType == type && (job->status() == JOBWAITING || job->status() == JOBWORKING)) return true;
+ }
+
+ return false;
+}
+
+void ProjectList::deleteJobsForClip(const QString &clipId)
+{
+ QMutexLocker lock(&m_jobMutex);
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->clipId() == clipId) {
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
+ }
+}
+
+void ProjectList::slotUpdateJobStatus(const QString id, int type, int status, const QString label, const QString actionName, const QString details)
+{
+ ProjectItem *item = getItemById(id);
+ if (!item) return;
+ slotUpdateJobStatus(item, type, status, label, actionName, details);
+
+}
+
+void ProjectList::slotUpdateJobStatus(ProjectItem *item, int type, int status, const QString &label, const QString &actionName, const QString details)
+{
+ item->setJobStatus((JOBTYPE) type, (CLIPJOBSTATUS) status);
+ if (status != JOBCRASHED) return;
+#if KDE_IS_VERSION(4,7,0)
+ QList<QAction *> actions = m_infoMessage->actions();
+ if (m_infoMessage->isHidden()) {
+ m_infoMessage->setText(label);
+ m_infoMessage->setWordWrap(m_infoMessage->text().length() > 35);
+ m_infoMessage->setMessageType(KMessageWidget::Warning);
+ }
+
+ if (!actionName.isEmpty()) {
+ QAction *action = NULL;
+ QList< KActionCollection * > collections = KActionCollection::allCollections();
+ for (int i = 0; i < collections.count(); i++) {
+ KActionCollection *coll = collections.at(i);
+ action = coll->action(actionName);
+ if (action) break;
+ }
+ if (action && !actions.contains(action)) m_infoMessage->addAction(action);
+ }
+ if (!details.isEmpty()) {
+ m_errorLog.append(details);
+ if (!actions.contains(m_logAction)) m_infoMessage->addAction(m_logAction);
+ }
+ m_infoMessage->animatedShow();
+#else
+ // warning for KDE < 4.7
+ KPassivePopup *passivePop = new KPassivePopup( this );
+ passivePop->setAutoDelete(true);
+ connect(passivePop, SIGNAL(clicked()), this, SLOT(slotClosePopup()));
+ m_errorLog.append(details);
+ KVBox *vb = new KVBox( passivePop );
+ KHBox *vh1 = new KHBox( vb );
+ KIcon icon("dialog-warning");
+ QLabel *iconLabel = new QLabel(vh1);
+ iconLabel->setPixmap(icon.pixmap(m_listView->iconSize()));
+ (void) new QLabel( label, vh1);
+ KHBox *box = new KHBox( vb );
+ QPushButton *but = new QPushButton( "Show log", box );
+ connect(but, SIGNAL(clicked(bool)), this, SLOT(slotShowJobLog()));
+
+ passivePop->setView( vb );
+ passivePop->show();
+
+#endif
+}
+
+void ProjectList::slotShowJobLog()
+{
+ KDialog d(this);
+ d.setButtons(KDialog::Close);
+ QTextEdit t(&d);
+ for (int i = 0; i < m_errorLog.count(); i++) {
+ if (i > 0) t.insertHtml("<br><hr /><br>");
+ t.insertPlainText(m_errorLog.at(i));
+ }
+ t.setReadOnly(true);
+ d.setMainWidget(&t);
+ d.exec();
+}
+
+QStringList ProjectList::getPendingJobs(const QString &id)
+{
+ QStringList result;
+ QMutexLocker lock(&m_jobMutex);
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->clipId() == id && (m_jobList.at(i)->status() == JOBWAITING || m_jobList.at(i)->status() == JOBWORKING)) {
+ // discard this job
+ result << m_jobList.at(i)->description;
+ }
+ }
+ return result;
+}
+
+void ProjectList::discardJobs(const QString &id, JOBTYPE type) {
+ QMutexLocker lock(&m_jobMutex);
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->clipId() == id && (m_jobList.at(i)->jobType == type || type == NOJOBTYPE)) {
+ // discard this job
+ m_jobList.at(i)->setStatus(JOBABORTED);
+ }
+ }
+}
+
+void ProjectList::slotStartFilterJob(ItemInfo info, const QString&id, const QString&filterName, const QString&filterParams, const QString&consumer, const QString&consumerParams, const QMap <QString, QString> &extraParams)
+{
+ ProjectItem *item = getItemById(id);
+ if (!item) return;
+ QStringList jobParams;
+ jobParams << QString::number(info.cropStart.frames(m_fps)) << QString::number((info.cropStart + info.cropDuration).frames(m_fps));
+ jobParams << QString() << filterName << filterParams << consumer << consumerParams << QString::number(info.startPos.frames(m_fps)) << QString::number(info.track);
+ MeltJob *job = new MeltJob(item->clipType(), id, jobParams, extraParams);
+ if (job->isExclusive() && hasPendingJob(item, job->jobType)) {
+ delete job;
+ return;
+ }
+ job->description = i18n("Filter %1", extraParams.value("finalfilter"));
+ m_jobList.append(job);
+ setJobStatus(item, job->jobType, JOBWAITING, 0, job->statusMessage());
+ slotCheckJobProcess();
+}
+
+void ProjectList::startClipFilterJob(const QString &filterName, const QString &condition)
+{
+ QStringList ids = getConditionalIds(condition);
+ QString destination;
+ ProjectItem *item = getItemById(ids.at(0));
+ if (!item) {
+ emit displayMessage(i18n("Cannot find clip to process filter %1", filterName), -2, ErrorMessage);
+ return;
+ }
+ if (ids.count() == 1) {
+ destination = item->clipUrl().path();
+ }
+ else {
+ destination = item->clipUrl().directory();
+ }
+ if (filterName == "motion_est") {
+ // Show config dialog
+ QPointer<QDialog> d = new QDialog(this);
+ Ui::SceneCutDialog_UI ui;
+ ui.setupUi(d);
+ // Set up categories
+ for (int i = 0; i < 5; ++i) {
+ ui.marker_type->insertItem(i, i18n("Category %1", i));
+ ui.marker_type->setItemData(i, CommentedTime::markerColor(i), Qt::DecorationRole);
+ }
+ ui.marker_type->setCurrentIndex(KdenliveSettings::default_marker_type());
+ if (d->exec() != QDialog::Accepted) {
+ delete d;
+ return;
+ }
+ // Autosplit filter
+ QStringList jobParams;
+ // Producer params
+ jobParams << QString();
+ // Filter params, use a smaller region of the image to speed up operation
+ // In fact, it's faster to rescale whole image than using part of it (bounding=\"25%x25%:15%x15\")
+ jobParams << filterName << "shot_change_list=0 denoise=0";
+ // Consumer
+ jobParams << "null" << "all=1 terminate_on_pause=1 real_time=-1 rescale=nearest deinterlace_method=onefield top_field_first=-1";
+ QMap <QString, QString> extraParams;
+ extraParams.insert("key", "shot_change_list");
+ extraParams.insert("projecttreefilter", "1");
+ QString keyword("%count");
+ extraParams.insert("resultmessage", i18n("Found %1 scenes.", keyword));
+ extraParams.insert("resize_profile", "160");
+ if (ui.store_data->isChecked()) {
+ // We want to save result as clip metadata
+ extraParams.insert("storedata", "1");
+ }
+ if (ui.zone_only->isChecked()) {
+ // We want to analyze only clip zone
+ extraParams.insert("zoneonly", "1");
+ }
+ if (ui.add_markers->isChecked()) {
+ // We want to create markers
+ extraParams.insert("addmarkers", QString::number(ui.marker_type->currentIndex()));
+ }
+ if (ui.cut_scenes->isChecked()) {
+ // We want to cut scenes
+ extraParams.insert("cutscenes", "1");
+ }
+ delete d;
+ processClipJob(ids, QString(), false, jobParams, i18n("Auto split"), extraParams);
+ }
+ else {
+ QPointer<ClipStabilize> d = new ClipStabilize(destination, ids.count(), filterName);
+ if (d->exec() == QDialog::Accepted) {
+ QMap <QString, QString> extraParams;
+ extraParams.insert("producer_profile", "1");
+ processClipJob(ids, d->destination(), d->autoAddClip(), d->params(), d->desc(), extraParams);
+ }
+ delete d;
+ }
+}
+
+void ProjectList::processClipJob(QStringList ids, const QString&destination, bool autoAdd, QStringList jobParams, const QString &description, QMap <QString, QString> extraParams)
+{
+ QStringList preParams;
+ // in and out
+ preParams << QString::number(0) << QString::number(-1);
+ // producer params
+ preParams << jobParams.takeFirst();
+ // filter name
+ preParams << jobParams.takeFirst();
+ // filter params
+ preParams << jobParams.takeFirst();
+ // consumer
+ QString consumer = jobParams.takeFirst();
+
+ foreach(const QString&id, ids) {
+ ProjectItem *item = getItemById(id);
+ if (!item) continue;
+ QStringList jobArgs;
+ if (extraParams.contains("zoneonly")) {
+ // Analyse clip zone only, remove in / out and replace with zone
+ preParams.takeFirst();
+ preParams.takeFirst();
+ QPoint zone = item->referencedClip()->zone();
+ jobArgs << QString::number(zone.x()) << QString::number(zone.y());
+ }
+ jobArgs << preParams;
+ if (ids.count() == 1) {
+ jobArgs << consumer + ':' + destination;
+ }
+ else {
+ jobArgs << consumer + ':' + destination + item->clipUrl().fileName() + ".mlt";
+ }
+ jobArgs << jobParams;
+
+ MeltJob *job = new MeltJob(item->clipType(), id, jobArgs, extraParams);
+ if (autoAdd) {
+ job->setAddClipToProject(true);
+ kDebug()<<"// ADDING TRUE";
+ }
+ else kDebug()<<"// ADDING FALSE!!!";
+
+ if (job->isExclusive() && hasPendingJob(item, job->jobType)) {
+ delete job;
+ return;
+ }
+ job->description = description;
+ m_jobList.append(job);
+ setJobStatus(item, job->jobType, JOBWAITING, 0, job->statusMessage());
+ }
+ slotCheckJobProcess();
+}
+
+void ProjectList::slotPrepareJobsMenu()
+{
+ ProjectItem *item;
+ if (!m_listView->currentItem() || m_listView->currentItem()->type() == PROJECTFOLDERTYPE)
+ return;
+ if (m_listView->currentItem()->type() == PROJECTSUBCLIPTYPE)
+ item = static_cast <ProjectItem*>(m_listView->currentItem()->parent());
+ else
+ item = static_cast <ProjectItem*>(m_listView->currentItem());
+ if (item && (item->flags() & Qt::ItemIsDragEnabled)) {
+ QString id = item->clipId();
+ m_discardCurrentClipJobs->setData(id);
+ QStringList jobs = getPendingJobs(id);
+ m_discardCurrentClipJobs->setEnabled(!jobs.isEmpty());
+ } else {
+ m_discardCurrentClipJobs->setData(QString());
+ m_discardCurrentClipJobs->setEnabled(false);
+ }
+}
+
+void ProjectList::slotDiscardClipJobs()
+{
+ QString id = m_discardCurrentClipJobs->data().toString();
+ if (id.isEmpty()) return;
+ discardJobs(id);
+}
+
+void ProjectList::updatePalette()
+{
+ m_infoLabel->setStyleSheet(SmallInfoLabel::getStyleSheet(QApplication::palette()));
+ m_listView->updateStyleSheet();
+}
+
+void ProjectList::slotResetInfoMessage()
+{
+#if KDE_IS_VERSION(4,7,0)
+ m_errorLog.clear();
+ QList<QAction *> actions = m_infoMessage->actions();
+ for (int i = 0; i < actions.count(); i++) {
+ m_infoMessage->removeAction(actions.at(i));
+ }
+#endif
+}
+
+void ProjectList::slotClosePopup()
+{
+ m_errorLog.clear();
+}
+
+void ProjectList::slotGotFilterJobResults(QString id, int , int , stringMap results, stringMap filterInfo)
+{
+ // Currently, only the first value of results is used
+ //kDebug()<<"// FILTER RES:\n"<<filterInfo<<"\n--------------\n"<<results;
+ ProjectItem *clip = getItemById(id);
+ if (!clip) return;
+ // Check for return value
+ int markersType = -1;
+ if (filterInfo.contains("addmarkers")) markersType = filterInfo.value("addmarkers").toInt();
+ if (results.isEmpty()) {
+ emit displayMessage(i18n("No data returned from clip analysis"), 0, ErrorMessage);
+ return;
+ }
+ bool dataProcessed = false;
+ QString key = filterInfo.value("key");
+ int offset = filterInfo.value("offset").toInt();
+ QStringList value = results.value(key).split(';', QString::SkipEmptyParts);
+ kDebug()<<"// RESULT; "<<key<<" = "<<value;
+ if (filterInfo.contains("resultmessage")) {
+ QString mess = filterInfo.value("resultmessage");
+ mess.replace("%count", QString::number(value.count()));
+ emit displayMessage(mess, 0, InformationMessage);
+ }
+ else emit displayMessage(i18n("Processing data analysis"), 0, InformationMessage);
+ if (filterInfo.contains("cutscenes")) {
+ // Check if we want to cut scenes from returned data
+ dataProcessed = true;
+ int cutPos = 0;
+ QUndoCommand *command = new QUndoCommand();
+ command->setText(i18n("Auto Split Clip"));
+ foreach (QString pos, value) {
+ if (!pos.contains("=")) continue;
+ int newPos = pos.section("=", 0, 0).toInt();
+ // Don't use scenes shorter than 1 second
+ if (newPos - cutPos < 24) continue;
+ (void) new AddClipCutCommand(this, id, cutPos + offset, newPos + offset, QString(), true, false, command);
+ cutPos = newPos;
+ }
+ if (command->childCount() == 0)
+ delete command;
+ else m_commandStack->push(command);
+ }
+ if (markersType >= 0) {
+ // Add markers from returned data
+ dataProcessed = true;
+ int cutPos = 0;
+ QUndoCommand *command = new QUndoCommand();
+ command->setText(i18n("Add Markers"));
+ QList <CommentedTime> markersList;
+ int index = 1;
+ foreach (QString pos, value) {
+ if (!pos.contains("=")) continue;
+ int newPos = pos.section("=", 0, 0).toInt();
+ // Don't use scenes shorter than 1 second
+ if (newPos - cutPos < 24) continue;
+ CommentedTime m(GenTime(newPos + offset, m_fps), QString::number(index), markersType);
+ markersList << m;
+ index++;
+ cutPos = newPos;
+ }
+ emit addMarkers(id, markersList);
+ }
+ if (!dataProcessed || filterInfo.contains("storedata")) {
+ // Store returned data as clip extra data
+ clip->referencedClip()->setAnalysisData(filterInfo.contains("displaydataname") ? filterInfo.value("displaydataname") : key, results.value(key), filterInfo.value("offset").toInt());
+ emit updateAnalysisData(clip->referencedClip());
+ }
+}
+
+
#include "projectlist.moc"
projects / kdenlive / blobdiff