git.sesse.net Git - kdenlive/blob - src/clipmanager.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Jean-Baptiste Mardelle (jb@kdenlive.org)        *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  18  ***************************************************************************/
  19
  20
  21 #include "clipmanager.h"
  22 #include "commands/addclipcommand.h"
  23 #include "kdenlivesettings.h"
  24 #include "docclipbase.h"
  25 #include "kdenlivedoc.h"
  26 #include "abstractclipitem.h"
  27 #include "abstractgroupitem.h"
  28 #include "titledocument.h"
  29 #include "subprojectitem.h"
  30 #include "kthumb.h"
  31
  32 #include <mlt++/Mlt.h>
  33
  34 #include <KDebug>
  35 #include <KMessageBox>
  36 #include <KFileDialog>
  37 #include <KApplication>
  38 #include <kio/netaccess.h>
  39 #include <kio/jobuidelegate.h>
  40
  41 #include <solid/device.h>
  42 #include <solid/storageaccess.h>
  43 #include <solid/storagedrive.h>
  44 #include <solid/storagevolume.h>
  45
  46 #include <QGraphicsItemGroup>
  47 #include <QtConcurrentRun>
  48
  49 #include <KFileMetaInfo>
  50
  51
  52 ClipManager::ClipManager(KdenliveDoc *doc) :
  53     QObject(),
  54     m_audioThumbsQueue(),
  55     m_doc(doc),
  56     m_abortThumb(false),
  57     m_closing(false),
  58     m_abortAudioThumb(false)
  59 {
  60     m_clipIdCounter = 1;
  61     m_folderIdCounter = 1;
  62     m_modifiedTimer.setInterval(1500);
  63     connect(&m_fileWatcher, SIGNAL(dirty(QString)), this, SLOT(slotClipModified(QString)));
  64     connect(&m_fileWatcher, SIGNAL(deleted(QString)), this, SLOT(slotClipMissing(QString)));
  65
  66     // Seems like a dirty signal is emitted anyways when a watched file is created, so don't react twice.
  67     //connect(&m_fileWatcher, SIGNAL(created(QString)), this, SLOT(slotClipAvailable(QString)));
  68     connect(&m_modifiedTimer, SIGNAL(timeout()), this, SLOT(slotProcessModifiedClips()));
  69
  70 #if KDE_IS_VERSION(4,5,0)
  71     KImageCache::deleteCache("kdenlive-thumbs");
  72     pixmapCache = new KImageCache("kdenlive-thumbs", 1000000);
  73     pixmapCache->setEvictionPolicy(KSharedDataCache::EvictOldest);
  74 #endif
  75 }
  76
  77 ClipManager::~ClipManager()
  78 {
  79     m_closing = true;
  80     m_abortThumb = true;
  81     m_abortAudioThumb = true;
  82     m_thumbsThread.waitForFinished();
  83     m_audioThumbsThread.waitForFinished();
  84     m_thumbsMutex.lock();
  85     m_requestedThumbs.clear();
  86     m_audioThumbsQueue.clear();
  87     m_thumbsMutex.unlock();
  88
  89     qDeleteAll(m_clipList);
  90     m_clipList.clear();
  91 #if KDE_IS_VERSION(4,5,0)
  92     delete pixmapCache;
  93 #endif
  94 }
  95
  96 void ClipManager::clear()
  97 {
  98     m_abortThumb = true;
  99     m_abortAudioThumb = true;
 100     m_thumbsThread.waitForFinished();
 101     m_audioThumbsThread.waitForFinished();
 102     m_thumbsMutex.lock();
 103     m_requestedThumbs.clear();
 104     m_audioThumbsQueue.clear();
 105     m_thumbsMutex.unlock();
 106     m_abortThumb = false;
 107     m_abortAudioThumb = false;
 108     m_folderList.clear();
 109     m_modifiedClips.clear();
 110     qDeleteAll(m_clipList);
 111     m_clipList.clear();
 112     m_clipIdCounter = 1;
 113     m_folderIdCounter = 1;
 114 #if KDE_IS_VERSION(4,5,0)
 115     pixmapCache->clear();
 116 #endif
 117 }
 118
 119 void ClipManager::clearCache()
 120 {
 121 #if KDE_IS_VERSION(4,5,0)
 122     pixmapCache->clear();
 123 #endif
 124 }
 125
 126 void ClipManager::slotRequestThumbs(const QString &id, const QList <int>& frames)
 127 {
 128     m_thumbsMutex.lock();
 129     foreach (int frame, frames) {
 130         m_requestedThumbs.insertMulti(id, frame);
 131     }
 132     m_thumbsMutex.unlock();
 133     if (!m_thumbsThread.isRunning() && !m_abortThumb) {
 134         m_thumbsThread = QtConcurrent::run(this, &ClipManager::slotGetThumbs);
 135     }
 136 }
 137
 138 void ClipManager::stopThumbs(const QString &id)
 139 {
 140     if (m_closing || (m_requestedThumbs.isEmpty() && m_processingThumbId != id && m_audioThumbsQueue.isEmpty() && m_processingAudioThumbId != id)) return;
 141     // Abort video thumbs for this clip
 142     m_abortThumb = true;
 143     m_thumbsThread.waitForFinished();
 144     m_thumbsMutex.lock();
 145     m_requestedThumbs.remove(id);
 146     m_audioThumbsQueue.removeAll(id);
 147     m_thumbsMutex.unlock();
 148     m_abortThumb = false;
 149
 150     // Abort audio thumbs for this clip
 151     if (m_processingAudioThumbId == id) {
 152         m_abortAudioThumb = true;
 153         m_audioThumbsThread.waitForFinished();
 154         m_abortAudioThumb = false;
 155     }
 156
 157     if (!m_thumbsThread.isRunning() && !m_requestedThumbs.isEmpty()) {
 158         m_thumbsThread = QtConcurrent::run(this, &ClipManager::slotGetThumbs);
 159     }
 160
 161     if (!m_audioThumbsThread.isRunning() && !m_audioThumbsQueue.isEmpty()) {
 162         m_audioThumbsThread = QtConcurrent::run(this, &ClipManager::slotGetAudioThumbs);
 163     }
 164 }
 165
 166 void ClipManager::slotGetThumbs()
 167 {
 168     QMap<QString, int>::const_iterator i;
 169     int max;
 170     int done = 0;
 171     int thumbType = 0; // 0 = timeline thumb, 1 = project clip zone thumb, 2 = clip properties thumb
 172
 173     while (!m_requestedThumbs.isEmpty() && !m_abortThumb) {
 174         m_thumbsMutex.lock();
 175         i = m_requestedThumbs.constBegin();
 176         m_processingThumbId = i.key();
 177         QList<int> values = m_requestedThumbs.values(m_processingThumbId);
 178         m_requestedThumbs.remove(m_processingThumbId);
 179         if (m_processingThumbId.startsWith("?")) {
 180             // if id starts with ?, it means the request comes from a clip property widget
 181             thumbType = 2;
 182             m_processingThumbId.remove(0, 1);
 183         }
 184         if (m_processingThumbId.startsWith("#")) {
 185             // if id starts with #, it means the request comes from project tree
 186             thumbType = 1;
 187             m_processingThumbId.remove(0, 1);
 188         }
 189         m_thumbsMutex.unlock();
 190         qSort(values);
 191         DocClipBase *clip = getClipById(m_processingThumbId);
 192         if (!clip) continue;
 193         max = m_requestedThumbs.size() + values.count();
 194         int pos;
 195         while (!values.isEmpty() && clip->thumbProducer() && !m_abortThumb) {
 196             pos = values.takeFirst();
 197             switch (thumbType) {
 198             case 1:
 199                 clip->thumbProducer()->getGenericThumb(pos, SubProjectItem::itemDefaultHeight(), thumbType);
 200                 break;
 201             case 2:
 202                 clip->thumbProducer()->getGenericThumb(pos, 180, thumbType);
 203                 break;
 204             default:
 205                 clip->thumbProducer()->getThumb(pos);
 206             }
 207             done++;
 208             if (max > 3) emit displayMessage(i18n("Loading thumbnails"), 100 * done / max);
 209         }
 210     }
 211     m_processingThumbId.clear();
 212     emit displayMessage(QString(), -1);
 213 }
 214
 215 void ClipManager::checkAudioThumbs()
 216 {
 217     if (!KdenliveSettings::audiothumbnails()) {
 218         if (m_audioThumbsThread.isRunning()) {
 219             m_abortAudioThumb = true;
 220             m_thumbsMutex.lock();
 221             m_audioThumbsQueue.clear();
 222             m_thumbsMutex.unlock();
 223             m_audioThumbsThread.waitForFinished();
 224             m_abortAudioThumb = false;
 225         }
 226         return;
 227     }
 228
 229     m_thumbsMutex.lock();
 230     for (int i = 0; i < m_clipList.count(); ++i) {
 231         DocClipBase *clip = m_clipList.at(i);
 232         if (clip->hasAudioThumb() && !clip->audioThumbCreated())
 233             m_audioThumbsQueue.append(m_clipList.at(i)->getId());
 234     }
 235     m_thumbsMutex.unlock();
 236     if (!m_audioThumbsThread.isRunning() && !m_audioThumbsQueue.isEmpty()) {
 237         m_audioThumbsThread = QtConcurrent::run(this, &ClipManager::slotGetAudioThumbs);
 238     }
 239 }
 240
 241 void ClipManager::askForAudioThumb(const QString &id)
 242 {
 243     DocClipBase *clip = getClipById(id);
 244     if (clip && KdenliveSettings::audiothumbnails() && (clip->hasAudioThumb())) {
 245         m_thumbsMutex.lock();
 246         if (!m_audioThumbsQueue.contains(id)) m_audioThumbsQueue.append(id);
 247         m_thumbsMutex.unlock();
 248         if (!m_audioThumbsThread.isRunning()) m_audioThumbsThread = QtConcurrent::run(this, &ClipManager::slotGetAudioThumbs);
 249     }
 250 }
 251
 252 void ClipManager::slotGetAudioThumbs()
 253 {
 254     Mlt::Profile prof((char*) KdenliveSettings::current_profile().toUtf8().constData());
 255     mlt_audio_format audioFormat = mlt_audio_s16;
 256     while (!m_abortAudioThumb && !m_audioThumbsQueue.isEmpty()) {
 257         m_thumbsMutex.lock();
 258         m_processingAudioThumbId = m_audioThumbsQueue.takeFirst();
 259         m_thumbsMutex.unlock();
 260         DocClipBase *clip = getClipById(m_processingAudioThumbId);
 261         if (!clip || clip->audioThumbCreated()) continue;
 262         KUrl url = clip->fileURL();
 263         QString hash = clip->getClipHash();
 264         if (hash.isEmpty()) continue;
 265         QString audioPath = projectFolder() + "/thumbs/" + hash + ".thumb";
 266         double lengthInFrames = clip->duration().frames(m_doc->fps());
 267         int frequency = 0;
 268         int channels = 0;
 269         QString data = clip->getProperty("frequency");
 270         if (!data.isEmpty()) frequency = data.toInt();
 271         if (frequency <= 0) frequency = 48000;
 272         data = clip->getProperty("channels");
 273         if (!data.isEmpty()) channels = data.toInt();
 274         if (channels <= 0) channels = 2;
 275         int arrayWidth = 20;
 276         double frame = 0.0;
 277         int maxVolume = 0;
 278         audioByteArray storeIn;
 279         QFile f(audioPath);
 280         if (QFileInfo(audioPath).size() > 0 && f.open(QIODevice::ReadOnly)) {
 281             const QByteArray channelarray = f.readAll();
 282             f.close();
 283             if (channelarray.size() != arrayWidth*(frame + lengthInFrames) * channels) {
 284                 kDebug() << "--- BROKEN THUMB FOR: " << url.fileName() << " ---------------------- ";
 285                 f.remove();
 286                 continue;
 287             }
 288             kDebug() << "reading audio thumbs from file";
 289
 290             int h1 = arrayWidth * channels;
 291             int h2 = (int) frame * h1;
 292             int h3;
 293             for (int z = (int) frame; z < (int)(frame + lengthInFrames) && !m_abortAudioThumb; z++) {
 294                 h3 = 0;
 295                 for (int c = 0; c < channels; c++) {
 296                     QByteArray audioArray(arrayWidth, '\x00');
 297                     for (int i = 0; i < arrayWidth; ++i) {
 298                         audioArray[i] = channelarray.at(h2 + h3 + i);
 299                         if (audioArray.at(i) > maxVolume) maxVolume = audioArray.at(i);
 300                     }
 301                     h3 += arrayWidth;
 302                     storeIn[z][c] = audioArray;
 303                 }
 304                 h2 += h1;
 305             }
 306             if (!m_abortAudioThumb) {
 307                 clip->setProperty("audio_max", QString::number(maxVolume - 64));
 308                 clip->updateAudioThumbnail(storeIn);
 309             }
 310             continue;
 311         }
 312
 313         if (!f.open(QIODevice::WriteOnly)) {
 314             kDebug() << "++++++++  ERROR WRITING TO FILE: " << audioPath;
 315             kDebug() << "++++++++  DISABLING AUDIO THUMBS";
 316             m_thumbsMutex.lock();
 317             m_audioThumbsQueue.clear();
 318             m_thumbsMutex.unlock();
 319             KdenliveSettings::setAudiothumbnails(false);
 320             break;
 321         }
 322
 323         Mlt::Producer producer(prof, url.path().toUtf8().constData());
 324         if (!producer.is_valid()) {
 325             kDebug() << "++++++++  INVALID CLIP: " << url.path();
 326             continue;
 327         }
 328
 329         producer.set("video_index", "-1");
 330
 331         if (KdenliveSettings::normaliseaudiothumbs()) {
 332             /*Mlt::Filter m_convert(prof, "volume");
 333             m_convert.set("gain", "normalise");
 334             producer.attach(m_convert);*/
 335         }
 336
 337         int last_val = 0;
 338         int val = 0;
 339         double framesPerSecond = mlt_producer_get_fps(producer.get_producer());
 340         Mlt::Frame *mlt_frame;
 341
 342         for (int z = (int) frame; z < (int)(frame + lengthInFrames) && producer.is_valid() &&  !m_abortAudioThumb; z++) {
 343             val = (int)((z - frame) / (frame + lengthInFrames) * 100.0);
 344             if (last_val != val && val > 1) {
 345                 setThumbsProgress(i18n("Creating audio thumbnail for %1", url.fileName()), val);
 346                 last_val = val;
 347             }
 348             producer.seek(z);
 349             mlt_frame = producer.get_frame();
 350             if (mlt_frame && mlt_frame->is_valid()) {
 351                 int samples = mlt_sample_calculator(framesPerSecond, frequency, mlt_frame->get_position());
 352                 qint16* pcm = static_cast<qint16*>(mlt_frame->get_audio(audioFormat, frequency, channels, samples));
 353                 for (int c = 0; c < channels; c++) {
 354                     QByteArray audioArray;
 355                     audioArray.resize(arrayWidth);
 356                     for (int i = 0; i < audioArray.size(); ++i) {
 357                         double pcmval = *(pcm + c + i * samples / audioArray.size());
 358                         if (pcmval >= 0) {
 359                             pcmval = sqrt(pcmval) / 2.83 + 64;
 360                             audioArray[i] = pcmval;
 361                             if (pcmval > maxVolume) maxVolume = pcmval;
 362                         }
 363                         else {
 364                             pcmval = -sqrt(-pcmval) / 2.83 + 64;
 365                             audioArray[i] = pcmval;
 366                             if (-pcmval > maxVolume) maxVolume = -pcmval;
 367                         }
 368                     }
 369                     f.write(audioArray);
 370                     storeIn[z][c] = audioArray;
 371                 }
 372             } else {
 373                 f.write(QByteArray(arrayWidth, '\x00'));
 374             }
 375             delete mlt_frame;
 376         }
 377         f.close();
 378         setThumbsProgress(i18n("Creating audio thumbnail for %1", url.fileName()), -1);
 379         if (m_abortAudioThumb) {
 380             f.remove();
 381         } else {
 382             clip->updateAudioThumbnail(storeIn);
 383             clip->setProperty("audio_max", QString::number(maxVolume - 64));
 384         }
 385     }
 386     m_processingAudioThumbId.clear();
 387 }
 388
 389 void ClipManager::setThumbsProgress(const QString &message, int progress)
 390 {
 391     m_doc->setThumbsProgress(message, progress);
 392 }
 393
 394 QList <DocClipBase*> ClipManager::documentClipList() const
 395 {
 396     return m_clipList;
 397 }
 398
 399 QMap <QString, QString> ClipManager::documentFolderList() const
 400 {
 401     return m_folderList;
 402 }
 403
 404 void ClipManager::addClip(DocClipBase *clip)
 405 {
 406     m_clipList.append(clip);
 407     if (clip->clipType() != COLOR && clip->clipType() != SLIDESHOW  && !clip->fileURL().isEmpty()) {
 408         // listen for file change
 409         //kDebug() << "// LISTEN FOR: " << clip->fileURL().path();
 410         m_fileWatcher.addFile(clip->fileURL().path());
 411     }
 412     const QString id = clip->getId();
 413     if (id.toInt() >= m_clipIdCounter) m_clipIdCounter = id.toInt() + 1;
 414     const QString gid = clip->getProperty("groupid");
 415     if (!gid.isEmpty() && gid.toInt() >= m_folderIdCounter) m_folderIdCounter = gid.toInt() + 1;
 416 }
 417
 418 void ClipManager::slotDeleteClips(QStringList ids)
 419 {
 420     QUndoCommand *delClips = new QUndoCommand();
 421     delClips->setText(i18np("Delete clip", "Delete clips", ids.size()));
 422
 423     for (int i = 0; i < ids.size(); ++i) {
 424         DocClipBase *clip = getClipById(ids.at(i));
 425         if (clip) {
 426             new AddClipCommand(m_doc, clip->toXML(), ids.at(i), false, delClips);
 427         }
 428     }
 429     m_doc->commandStack()->push(delClips);
 430 }
 431
 432 void ClipManager::deleteClip(const QString &clipId)
 433 {
 434     for (int i = 0; i < m_clipList.count(); ++i) {
 435         if (m_clipList.at(i)->getId() == clipId) {
 436             DocClipBase *clip = m_clipList.takeAt(i);
 437             if (clip->clipType() != COLOR && clip->clipType() != SLIDESHOW  && !clip->fileURL().isEmpty()) {
 438                 //if (m_clipList.at(i)->clipType() == IMAGE || m_clipList.at(i)->clipType() == AUDIO || (m_clipList.at(i)->clipType() == TEXT && !m_clipList.at(i)->fileURL().isEmpty())) {
 439                 // listen for file change
 440                 m_fileWatcher.removeFile(clip->fileURL().path());
 441             }
 442             delete clip;
 443             clip = NULL;
 444             break;
 445         }
 446     }
 447 }
 448
 449 DocClipBase *ClipManager::getClipAt(int pos)
 450 {
 451     return m_clipList.at(pos);
 452 }
 453
 454 DocClipBase *ClipManager::getClipById(QString clipId)
 455 {
 456     //kDebug() << "++++  CLIP MAN, LOOKING FOR CLIP ID: " << clipId;
 457     clipId = clipId.section('_', 0, 0);
 458     for (int i = 0; i < m_clipList.count(); ++i) {
 459         if (m_clipList.at(i)->getId() == clipId) {
 460             //kDebug() << "++++  CLIP MAN, FOUND FOR CLIP ID: " << clipId;
 461             return m_clipList.at(i);
 462         }
 463     }
 464     return NULL;
 465 }
 466
 467 const QList <DocClipBase *> ClipManager::getClipByResource(const QString &resource)
 468 {
 469     QList <DocClipBase *> list;
 470     QString clipResource;
 471     QString proxyResource;
 472     for (int i = 0; i < m_clipList.count(); ++i) {
 473         clipResource = m_clipList.at(i)->getProperty("resource");
 474         proxyResource = m_clipList.at(i)->getProperty("proxy");
 475         if (clipResource.isEmpty()) clipResource = m_clipList.at(i)->getProperty("colour");
 476         if (clipResource == resource || proxyResource == resource) {
 477             list.append(m_clipList.at(i));
 478         }
 479     }
 480     return list;
 481 }
 482
 483
 484 void ClipManager::clearUnusedProducers()
 485 {
 486     for (int i = 0; i < m_clipList.count(); ++i) {
 487         if (m_clipList.at(i)->numReferences() == 0) m_clipList.at(i)->deleteProducers();
 488     }
 489 }
 490
 491 void ClipManager::resetProducersList(const QList <Mlt::Producer *> prods, bool displayRatioChanged, bool fpsChanged)
 492 {
 493     for (int i = 0; i < m_clipList.count(); ++i) {
 494         if (m_clipList.at(i)->numReferences() > 0 || displayRatioChanged || fpsChanged) {
 495             m_clipList.at(i)->deleteProducers();
 496         }
 497     }
 498     QString id;
 499     Mlt::Producer *prod;
 500     QStringList brokenClips;
 501     for (int i = 0; i < prods.count(); ++i) {
 502         prod = prods.at(i);
 503         id = prod->get("id");
 504         if (id.contains('_')) id = id.section('_', 0, 0);
 505         DocClipBase *clip = getClipById(id);
 506         QString markup = prod->get("markup");
 507         if (prod->is_blank() || !prod->is_valid() || !markup.isEmpty()) {
 508             // The clip is broken (missing proxy or source clip)
 509             kDebug()<<"// WARNING, CLIP "<<id<<" Cannot be loaded";
 510             brokenClips << id;
 511         }
 512         else if (clip) {
 513             clip->setProducer(prod, false, true);
 514         }
 515     }
 516     emit checkAllClips(displayRatioChanged, fpsChanged, brokenClips);
 517 }
 518
 519 void ClipManager::slotAddClip(KIO::Job *job, const KUrl &, const KUrl &dst)
 520 {
 521     KIO::MetaData meta = job->metaData();
 522     QMap <QString, QString> data;
 523     data.insert("group", meta.value("group"));
 524     data.insert("groupid", meta.value("groupid"));
 525     data.insert("comment", meta.value("comment"));
 526     kDebug()<<"Finished copying: "<<dst<<" / "<<meta.value("group")<<" / "<<meta.value("groupid");
 527     slotAddClipList(KUrl::List () << dst, data);
 528 }
 529
 530 void ClipManager::slotAddClipList(const KUrl::List &urls, const QMap <QString, QString> &data)
 531 {
 532     QUndoCommand *addClips = new QUndoCommand();
 533     // Update list of removable volumes
 534     //TODO: update only when new volume is plugged / unplugged
 535     listRemovableVolumes();
 536     foreach(const KUrl & file, urls) {
 537         if (QFile::exists(file.path())) {//KIO::NetAccess::exists(file, KIO::NetAccess::SourceSide, NULL)) {
 538             if (!data.contains("bypassDuplicate") && !getClipByResource(file.path()).empty()) {
 539                 if (KMessageBox::warningContinueCancel(kapp->activeWindow(), i18n("Clip <b>%1</b><br />already exists in project, what do you want to do?", file.path()), i18n("Clip already exists")) == KMessageBox::Cancel)
 540                     continue;
 541             }
 542             if (isOnRemovableDevice(file)) {
 543                 int answer = KMessageBox::warningYesNoCancel(kapp->activeWindow(), i18n("Clip <b>%1</b><br /> is on a removable device, will not be available when device is unplugged", file.path()), i18n("File on a Removable Device"), KGuiItem(i18n("Copy file to project folder")), KGuiItem(i18n("Continue")), KStandardGuiItem::cancel(), QString("copyFilesToProjectFolder"));
 544                 if (answer == KMessageBox::Cancel) continue;
 545                 else if (answer == KMessageBox::Yes) {
 546                     // Copy files to project folder
 547                     QString sourcesFolder = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "clips/";
 548                     KIO::NetAccess::mkdir(sourcesFolder, kapp->activeWindow());
 549                     //KIO::filesize_t m_requestedSize;
 550                     KIO::CopyJob *copyjob = KIO::copy (file, KUrl(sourcesFolder));
 551                     //TODO: for some reason, passing metadata does not work...
 552                     copyjob->addMetaData("group", data.value("group"));
 553                     copyjob->addMetaData("groupId", data.value("groupId"));
 554                     copyjob->addMetaData("comment", data.value("comment"));
 555                     copyjob->ui()->setWindow(kapp->activeWindow());
 556                     connect(copyjob, SIGNAL(copyingDone(KIO::Job*,KUrl,KUrl,time_t,bool,bool)), this, SLOT(slotAddClip(KIO::Job*,KUrl,KUrl)));
 557                     continue;
 558                 }
 559             }
 560             kDebug() << "Adding clip: " << file.path();
 561             QDomDocument doc;
 562             QDomElement prod = doc.createElement("producer");
 563             doc.appendChild(prod);
 564             prod.setAttribute("resource", file.path());
 565             uint id = m_clipIdCounter++;
 566             prod.setAttribute("id", QString::number(id));
 567             if (data.contains("comment")) prod.setAttribute("description", data.value("comment"));
 568             if (data.contains("group")) {
 569                 prod.setAttribute("groupname", data.value("group"));
 570                 prod.setAttribute("groupid", data.value("groupId"));
 571             }
 572             if (data.contains("video_index")) prod.setAttribute("video_index", data.value("video_index"));
 573             if (data.contains("audio_index")) prod.setAttribute("audio_index", data.value("audio_index"));
 574
 575             KMimeType::Ptr type = KMimeType::findByUrl(file);
 576             if (type->name().startsWith("image/")) {
 577                 prod.setAttribute("type", (int) IMAGE);
 578                 prod.setAttribute("in", 0);
 579                 prod.setAttribute("out", m_doc->getFramePos(KdenliveSettings::image_duration()) - 1);
 580                 if (KdenliveSettings::autoimagetransparency()) prod.setAttribute("transparency", 1);
 581                 // Read EXIF metadata for JPEG
 582                 if (type->is("image/jpeg")) {
 583                     KFileMetaInfo metaInfo(file.path(), QString("image/jpeg"), KFileMetaInfo::TechnicalInfo);
 584                     const QHash<QString, KFileMetaInfoItem> metaInfoItems = metaInfo.items();
 585                     foreach(const KFileMetaInfoItem & metaInfoItem, metaInfoItems) {
 586                         QDomElement meta = doc.createElement("metaproperty");
 587                         meta.setAttribute("name", "meta.attr." + metaInfoItem.name().section('#', 1));
 588                         QDomText value = doc.createTextNode(metaInfoItem.value().toString());
 589                         meta.setAttribute("tool", "KDE Metadata");
 590                         meta.appendChild(value);
 591                         prod.appendChild(meta);
 592                     }
 593                 }
 594             } else if (type->is("application/x-kdenlivetitle")) {
 595                 // opening a title file
 596                 QDomDocument txtdoc("titledocument");
 597                 QFile txtfile(file.path());
 598                 if (txtfile.open(QIODevice::ReadOnly) && txtdoc.setContent(&txtfile)) {
 599                     txtfile.close();
 600                     prod.setAttribute("type", (int) TEXT);
 601                     // extract embeded images
 602                     QDomNodeList items = txtdoc.elementsByTagName("content");
 603                     for (int i = 0; i < items.count() ; ++i) {
 604                         QDomElement content = items.item(i).toElement();
 605                         if (content.hasAttribute("base64")) {
 606                             QString titlesFolder = m_doc->projectFolder().path(KUrl::AddTrailingSlash) + "titles/";
 607                             QString path = TitleDocument::extractBase64Image(titlesFolder, content.attribute("base64"));
 608                             if (!path.isEmpty()) {
 609                                 content.setAttribute("url", path);
 610                                 content.removeAttribute("base64");
 611                             }
 612                         }
 613                     }
 614                     prod.setAttribute("transparency", 1);
 615                     prod.setAttribute("in", 0);
 616                     if (!txtdoc.documentElement().hasAttribute("out")) {
 617                         prod.setAttribute("out", m_doc->getFramePos(KdenliveSettings::title_duration()) - 1);
 618                         txtdoc.documentElement().setAttribute("out", m_doc->getFramePos(KdenliveSettings::title_duration()) - 1);
 619                     }
 620                     else {
 621                         int out = txtdoc.documentElement().attribute("out").toInt();
 622                         if (out >= 0)
 623                             prod.setAttribute("out", out);
 624                         else {
 625                             prod.setAttribute("out", m_doc->getFramePos(KdenliveSettings::title_duration()) - 1);
 626                             txtdoc.documentElement().setAttribute("out", m_doc->getFramePos(KdenliveSettings::title_duration()) - 1);
 627                         }
 628                     }
 629                     QString titleData = txtdoc.toString();
 630                     prod.setAttribute("xmldata", titleData);
 631                 } else
 632                     txtfile.close();
 633             }
 634             new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true, addClips);
 635         }
 636         else kDebug()<<"// CANNOT READ FILE: "<<file;
 637     }
 638     if (addClips->childCount() > 0) {
 639         addClips->setText(i18np("Add clip", "Add clips", addClips->childCount()));
 640         m_doc->commandStack()->push(addClips);
 641     }
 642 }
 643
 644 void ClipManager::slotAddClipFile(const KUrl &url, const QMap <QString, QString> &data)
 645 {
 646     slotAddClipList(KUrl::List(url), data);
 647 }
 648
 649 void ClipManager::slotAddXmlClipFile(const QString &name, const QDomElement &xml, const QString &group, const QString &groupId)
 650 {
 651     QDomDocument doc;
 652     doc.appendChild(doc.importNode(xml, true));
 653     QDomElement prod = doc.documentElement();
 654     prod.setAttribute("type", (int) PLAYLIST);
 655     uint id = m_clipIdCounter++;
 656     prod.setAttribute("id", QString::number(id));
 657     prod.setAttribute("name", name);
 658     if (!group.isEmpty()) {
 659         prod.setAttribute("groupname", group);
 660         prod.setAttribute("groupid", groupId);
 661     }
 662     AddClipCommand *command = new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true);
 663     m_doc->commandStack()->push(command);
 664 }
 665
 666 void ClipManager::slotAddColorClipFile(const QString &name, const QString &color, const QString &duration, const QString &group, const QString &groupId)
 667 {
 668     QDomDocument doc;
 669     QDomElement prod = doc.createElement("producer");
 670     doc.appendChild(prod);
 671     prod.setAttribute("mlt_service", "colour");
 672     prod.setAttribute("colour", color);
 673     prod.setAttribute("type", (int) COLOR);
 674     uint id = m_clipIdCounter++;
 675     prod.setAttribute("id", QString::number(id));
 676     prod.setAttribute("in", "0");
 677     prod.setAttribute("out", m_doc->getFramePos(duration) - 1);
 678     prod.setAttribute("name", name);
 679     if (!group.isEmpty()) {
 680         prod.setAttribute("groupname", group);
 681         prod.setAttribute("groupid", groupId);
 682     }
 683     AddClipCommand *command = new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true);
 684     m_doc->commandStack()->push(command);
 685 }
 686
 687 void ClipManager::slotAddSlideshowClipFile(QMap <QString, QString> properties, const QString &group, const QString &groupId)
 688 {
 689     QDomDocument doc;
 690     QDomElement prod = doc.createElement("producer");
 691     doc.appendChild(prod);
 692     QMap<QString, QString>::const_iterator i = properties.constBegin();
 693     while (i != properties.constEnd()) {
 694         prod.setAttribute(i.key(), i.value());
 695         ++i;
 696     }
 697     prod.setAttribute("type", (int) SLIDESHOW);
 698     uint id = m_clipIdCounter++;
 699     if (!group.isEmpty()) {
 700         prod.setAttribute("groupname", group);
 701         prod.setAttribute("groupid", groupId);
 702     }
 703     AddClipCommand *command = new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true);
 704     m_doc->commandStack()->push(command);
 705 }
 706
 707
 708
 709 void ClipManager::slotAddTextClipFile(const QString &titleName, int duration, const QString &xml, const QString &group, const QString &groupId)
 710 {
 711     QDomDocument doc;
 712     QDomElement prod = doc.createElement("producer");
 713     doc.appendChild(prod);
 714     //prod.setAttribute("resource", imagePath);
 715     prod.setAttribute("name", titleName);
 716     prod.setAttribute("xmldata", xml);
 717     uint id = m_clipIdCounter++;
 718     prod.setAttribute("id", QString::number(id));
 719     if (!group.isEmpty()) {
 720         prod.setAttribute("groupname", group);
 721         prod.setAttribute("groupid", groupId);
 722     }
 723     prod.setAttribute("type", (int) TEXT);
 724     prod.setAttribute("transparency", "1");
 725     prod.setAttribute("in", "0");
 726     prod.setAttribute("out", duration - 1);
 727     AddClipCommand *command = new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true);
 728     m_doc->commandStack()->push(command);
 729 }
 730
 731 void ClipManager::slotAddTextTemplateClip(QString titleName, const KUrl &path, const QString &group, const QString &groupId)
 732 {
 733     QDomDocument doc;
 734     QDomElement prod = doc.createElement("producer");
 735     doc.appendChild(prod);
 736     prod.setAttribute("name", titleName);
 737     prod.setAttribute("resource", path.path());
 738     uint id = m_clipIdCounter++;
 739     prod.setAttribute("id", QString::number(id));
 740     if (!group.isEmpty()) {
 741         prod.setAttribute("groupname", group);
 742         prod.setAttribute("groupid", groupId);
 743     }
 744     prod.setAttribute("type", (int) TEXT);
 745     prod.setAttribute("transparency", "1");
 746     prod.setAttribute("in", "0");
 747
 748     int duration = 0;
 749     QDomDocument titledoc;
 750     QFile txtfile(path.path());
 751     if (txtfile.open(QIODevice::ReadOnly) && titledoc.setContent(&txtfile)) {
 752         txtfile.close();
 753         if (titledoc.documentElement().hasAttribute("duration")) {
 754             duration = titledoc.documentElement().attribute("duration").toInt();
 755         }
 756         else {
 757             // keep some time for backwards compatibility - 26/12/12
 758             duration = titledoc.documentElement().attribute("out").toInt();
 759         }
 760     } else txtfile.close();
 761
 762     if (duration == 0) duration = m_doc->getFramePos(KdenliveSettings::title_duration());
 763     prod.setAttribute("out", duration - 1);
 764
 765     AddClipCommand *command = new AddClipCommand(m_doc, doc.documentElement(), QString::number(id), true);
 766     m_doc->commandStack()->push(command);
 767 }
 768
 769 int ClipManager::getFreeClipId()
 770 {
 771     return m_clipIdCounter++;
 772 }
 773
 774 int ClipManager::getFreeFolderId()
 775 {
 776     return m_folderIdCounter++;
 777 }
 778
 779 int ClipManager::lastClipId() const
 780 {
 781     return m_clipIdCounter - 1;
 782 }
 783
 784 QString ClipManager::projectFolder() const
 785 {
 786     return m_doc->projectFolder().path();
 787 }
 788
 789 void ClipManager::addFolder(const QString &id, const QString &name)
 790 {
 791     m_folderList.insert(id, name);
 792 }
 793
 794 void ClipManager::deleteFolder(const QString &id)
 795 {
 796     m_folderList.remove(id);
 797 }
 798
 799 AbstractGroupItem *ClipManager::createGroup()
 800 {
 801     AbstractGroupItem *group = new AbstractGroupItem(m_doc->fps());
 802     m_groupsList.append(group);
 803     return group;
 804 }
 805
 806 void ClipManager::removeGroup(AbstractGroupItem *group)
 807 {
 808     m_groupsList.removeAll(group);
 809 }
 810
 811 QDomElement ClipManager::groupsXml() const
 812 {
 813     QDomDocument doc;
 814     QDomElement groups = doc.createElement("groups");
 815     doc.appendChild(groups);
 816     for (int i = 0; i < m_groupsList.count(); ++i) {
 817         QDomElement group = doc.createElement("group");
 818         groups.appendChild(group);
 819         QList <QGraphicsItem *> children = m_groupsList.at(i)->childItems();
 820         for (int j = 0; j < children.count(); j++) {
 821             if (children.at(j)->type() == AVWIDGET || children.at(j)->type() == TRANSITIONWIDGET) {
 822                 AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(j));
 823                 ItemInfo info = item->info();
 824                 if (item->type() == AVWIDGET) {
 825                     QDomElement clip = doc.createElement("clipitem");
 826                     clip.setAttribute("track", info.track);
 827                     clip.setAttribute("position", info.startPos.frames(m_doc->fps()));
 828                     group.appendChild(clip);
 829                 } else if (item->type() == TRANSITIONWIDGET) {
 830                     QDomElement clip = doc.createElement("transitionitem");
 831                     clip.setAttribute("track", info.track);
 832                     clip.setAttribute("position", info.startPos.frames(m_doc->fps()));
 833                     group.appendChild(clip);
 834                 }
 835             }
 836         }
 837     }
 838     return doc.documentElement();
 839 }
 840
 841
 842 void ClipManager::slotClipModified(const QString &path)
 843 {
 844     //kDebug() << "// CLIP: " << path << " WAS MODIFIED";
 845     const QList <DocClipBase *> list = getClipByResource(path);
 846     for (int i = 0; i < list.count(); ++i) {
 847         DocClipBase *clip = list.at(i);
 848         if (clip != NULL) {
 849             QString id = clip->getId();
 850             if (!m_modifiedClips.contains(id))
 851                 emit modifiedClip(id);
 852             m_modifiedClips[id] = QTime::currentTime();
 853         }
 854     }
 855     if (!m_modifiedTimer.isActive()) m_modifiedTimer.start();
 856 }
 857
 858 void ClipManager::slotProcessModifiedClips()
 859 {
 860     if (!m_modifiedClips.isEmpty()) {
 861         QMapIterator<QString, QTime> i(m_modifiedClips);
 862         while (i.hasNext()) {
 863             i.next();
 864             if (QTime::currentTime().msecsTo(i.value()) <= -1500) {
 865                 emit reloadClip(i.key());
 866                 m_modifiedClips.remove(i.key());
 867                 break;
 868             }
 869         }
 870     }
 871     if (m_modifiedClips.isEmpty()) m_modifiedTimer.stop();
 872 }
 873
 874 void ClipManager::slotClipMissing(const QString &path)
 875 {
 876     // kDebug() << "// CLIP: " << path << " WAS MISSING";
 877     const QList <DocClipBase *> list = getClipByResource(path);
 878     for (int i = 0; i < list.count(); ++i) {
 879         DocClipBase *clip = list.at(i);
 880         if (clip != NULL) emit missingClip(clip->getId());
 881     }
 882 }
 883
 884 void ClipManager::slotClipAvailable(const QString &path)
 885 {
 886     // kDebug() << "// CLIP: " << path << " WAS ADDED";
 887     const QList <DocClipBase *> list = getClipByResource(path);
 888     for (int i = 0; i < list.count(); ++i) {
 889         DocClipBase *clip = list.at(i);
 890         if (clip != NULL) emit availableClip(clip->getId());
 891     }
 892 }
 893
 894 int ClipManager::clipsCount() const
 895 {
 896     return m_clipList.count();
 897 }
 898
 899
 900 void ClipManager::listRemovableVolumes()
 901 {
 902     QList<SolidVolumeInfo> volumes;
 903     m_removableVolumes.clear();
 904
 905     QList<Solid::Device> devices = Solid::Device::listFromType(Solid::DeviceInterface::StorageAccess);
 906
 907     foreach(const Solid::Device &accessDevice, devices)
 908     {
 909         // check for StorageAccess
 910         if (!accessDevice.is<Solid::StorageAccess>())
 911             continue;
 912
 913         const Solid::StorageAccess *access = accessDevice.as<Solid::StorageAccess>();
 914
 915         if (!access->isAccessible())
 916             continue;
 917
 918         // check for StorageDrive
 919         Solid::Device driveDevice;
 920         for (Solid::Device currentDevice = accessDevice; currentDevice.isValid(); currentDevice = currentDevice.parent())
 921         {
 922             if (currentDevice.is<Solid::StorageDrive>())
 923             {
 924                 driveDevice = currentDevice;
 925                 break;
 926             }
 927         }
 928         if (!driveDevice.isValid())
 929             continue;
 930
 931         Solid::StorageDrive *drive = driveDevice.as<Solid::StorageDrive>();
 932         if (!drive->isRemovable()) continue;
 933
 934         // check for StorageVolume
 935         Solid::Device volumeDevice;
 936         for (Solid::Device currentDevice = accessDevice; currentDevice.isValid(); currentDevice = currentDevice.parent())
 937         {
 938             if (currentDevice.is<Solid::StorageVolume>())
 939             {
 940                 volumeDevice = currentDevice;
 941                 break;
 942             }
 943         }
 944         if (!volumeDevice.isValid())
 945             continue;
 946
 947         Solid::StorageVolume *volume = volumeDevice.as<Solid::StorageVolume>();
 948
 949         SolidVolumeInfo info;
 950         info.path = access->filePath();
 951         info.isMounted = access->isAccessible();
 952         if (!info.path.isEmpty() && !info.path.endsWith('/'))
 953             info.path += '/';
 954         info.uuid = volume->uuid();
 955         info.label = volume->label();
 956         info.isRemovable = drive->isRemovable();
 957         m_removableVolumes << info;
 958     }
 959 }
 960
 961 bool ClipManager::isOnRemovableDevice(const KUrl &url)
 962 {
 963     SolidVolumeInfo volume;
 964     QString path = url.path(KUrl::RemoveTrailingSlash);
 965     int volumeMatch = 0;
 966
 967     //FIXME: Network shares! Here we get only the volume of the mount path...
 968     // This is probably not really clean. But Solid does not help us.
 969     foreach (const SolidVolumeInfo &v, m_removableVolumes)
 970     {
 971         if (v.isMounted && !v.path.isEmpty() && path.startsWith(v.path))
 972         {
 973             int length = v.path.length();
 974             if (length > volumeMatch)
 975             {
 976                 volumeMatch = v.path.length();
 977                 volume = v;
 978             }
 979         }
 980     }
 981
 982     return volumeMatch;
 983 }
 984
 985 void ClipManager::projectTreeThumbReady(const QString &id, int frame, const QImage &img, int type)
 986 {
 987     switch (type) {
 988     case 2:
 989         emit gotClipPropertyThumbnail(id, img);
 990         break;
 991     default:
 992         emit thumbReady(id, frame, img);
 993     }
 994 }
 995
 996
 997 #include "clipmanager.moc"