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