diff --git a/src/bin/projectclip.cpp b/src/bin/projectclip.cpp
index c069f0c84..77082e169 100644
--- a/src/bin/projectclip.cpp
+++ b/src/bin/projectclip.cpp
@@ -1,1442 +1,1444 @@
 /*
 Copyright (C) 2012  Till Theato <root@ttill.de>
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 This file is part of Kdenlive. See www.kdenlive.org.
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License as
 published by the Free Software Foundation; either version 2 of
 the License or (at your option) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "projectclip.h"
 #include "bin.h"
 #include "core.h"
 #include "doc/docundostack.hpp"
 #include "doc/kdenlivedoc.h"
 #include "doc/kthumb.h"
 #include "effects/effectstack/model/effectstackmodel.hpp"
 #include "jobs/jobmanager.h"
 #include "jobs/loadjob.hpp"
 #include "jobs/thumbjob.hpp"
 #include "kdenlivesettings.h"
 #include "lib/audio/audioStreamInfo.h"
 #include "mltcontroller/clipcontroller.h"
 #include "mltcontroller/clippropertiescontroller.h"
 #include "model/markerlistmodel.hpp"
 #include "profiles/profilemodel.hpp"
 #include "project/projectcommands.h"
 #include "project/projectmanager.h"
 #include "projectfolder.h"
 #include "projectitemmodel.h"
 #include "projectsubclip.h"
 #include "timecode.h"
 #include "timeline2/model/snapmodel.hpp"
 
 #include "utils/thumbnailcache.hpp"
 #include "xml/xml.hpp"
 #include <QPainter>
 #include <jobs/proxyclipjob.h>
 #include <kimagecache.h>
 
 #include "kdenlive_debug.h"
 #include "logger.hpp"
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <QApplication>
 #include <QCryptographicHash>
 #include <QDir>
 #include <QDomElement>
 #include <QFile>
 #include <QtConcurrent>
 #include <utility>
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #pragma GCC diagnostic ignored "-Wshadow"
 #pragma GCC diagnostic ignored "-Wpedantic"
 #include <rttr/registration>
 #pragma GCC diagnostic pop
 RTTR_REGISTRATION
 {
     using namespace rttr;
     registration::class_<ProjectClip>("ProjectClip");
 }
 
 ProjectClip::ProjectClip(const QString &id, const QIcon &thumb, std::shared_ptr<ProjectItemModel> model, std::shared_ptr<Mlt::Producer> producer)
     : AbstractProjectItem(AbstractProjectItem::ClipItem, id, model)
     , ClipController(id, producer)
     , m_thumbsProducer(nullptr)
 {
     m_markerModel = std::make_shared<MarkerListModel>(id, pCore->projectManager()->undoStack());
     m_clipStatus = StatusReady;
     m_name = clipName();
     m_duration = getStringDuration();
     m_inPoint = 0;
     m_date = date;
     m_description = ClipController::description();
     if (m_clipType == ClipType::Audio) {
         m_thumbnail = QIcon::fromTheme(QStringLiteral("audio-x-generic"));
     } else {
         m_thumbnail = thumb;
     }
     // Make sure we have a hash for this clip
     hash();
     connect(m_markerModel.get(), &MarkerListModel::modelChanged, [&]() { setProducerProperty(QStringLiteral("kdenlive:markers"), m_markerModel->toJson()); });
     QString markers = getProducerProperty(QStringLiteral("kdenlive:markers"));
     if (!markers.isEmpty()) {
         QMetaObject::invokeMethod(m_markerModel.get(), "importFromJson", Qt::QueuedConnection, Q_ARG(const QString &, markers), Q_ARG(bool, true),
                                   Q_ARG(bool, false));
     }
     connectEffectStack();
 }
 
 // static
 std::shared_ptr<ProjectClip> ProjectClip::construct(const QString &id, const QIcon &thumb, std::shared_ptr<ProjectItemModel> model,
                                                     std::shared_ptr<Mlt::Producer> producer)
 {
     std::shared_ptr<ProjectClip> self(new ProjectClip(id, thumb, model, producer));
     baseFinishConstruct(self);
     self->m_effectStack->importEffects(producer, PlaylistState::Disabled, true);
     model->loadSubClips(id, self->getPropertiesFromPrefix(QStringLiteral("kdenlive:clipzone.")));
     return self;
 }
 
 ProjectClip::ProjectClip(const QString &id, const QDomElement &description, const QIcon &thumb, std::shared_ptr<ProjectItemModel> model)
     : AbstractProjectItem(AbstractProjectItem::ClipItem, id, model)
     , ClipController(id)
     , m_thumbsProducer(nullptr)
 {
     m_clipStatus = StatusWaiting;
     m_thumbnail = thumb;
     m_markerModel = std::make_shared<MarkerListModel>(m_binId, pCore->projectManager()->undoStack());
     if (description.hasAttribute(QStringLiteral("type"))) {
         m_clipType = (ClipType::ProducerType)description.attribute(QStringLiteral("type")).toInt();
         if (m_clipType == ClipType::Audio) {
             m_thumbnail = QIcon::fromTheme(QStringLiteral("audio-x-generic"));
         }
     }
     m_temporaryUrl = getXmlProperty(description, QStringLiteral("resource"));
     QString clipName = getXmlProperty(description, QStringLiteral("kdenlive:clipname"));
     if (!clipName.isEmpty()) {
         m_name = clipName;
     } else if (!m_temporaryUrl.isEmpty()) {
         m_name = QFileInfo(m_temporaryUrl).fileName();
     } else {
         m_name = i18n("Untitled");
     }
     connect(m_markerModel.get(), &MarkerListModel::modelChanged, [&]() { setProducerProperty(QStringLiteral("kdenlive:markers"), m_markerModel->toJson()); });
 }
 
 std::shared_ptr<ProjectClip> ProjectClip::construct(const QString &id, const QDomElement &description, const QIcon &thumb,
                                                     std::shared_ptr<ProjectItemModel> model)
 {
     std::shared_ptr<ProjectClip> self(new ProjectClip(id, description, thumb, model));
     baseFinishConstruct(self);
     return self;
 }
 
 ProjectClip::~ProjectClip()
 {
     // controller is deleted in bincontroller
     m_thumbMutex.lock();
     m_requestedThumbs.clear();
     m_thumbMutex.unlock();
     m_thumbThread.waitForFinished();
     audioFrameCache.clear();
 }
 
 void ProjectClip::connectEffectStack()
 {
     connect(m_effectStack.get(), &EffectStackModel::modelChanged, this, &ProjectClip::updateChildProducers);
     connect(m_effectStack.get(), &EffectStackModel::dataChanged, this, &ProjectClip::updateChildProducers);
     connect(m_effectStack.get(), &EffectStackModel::dataChanged, [&]() {
         if (auto ptr = m_model.lock()) {
             std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                            AbstractProjectItem::IconOverlay);
         }
     });
     /*connect(m_effectStack.get(), &EffectStackModel::modelChanged, [&](){
         qDebug()<<"/ / / STACK CHANGED";
         updateChildProducers();
     });*/
 }
 
 QString ProjectClip::getToolTip() const
 {
     return url();
 }
 
 QString ProjectClip::getXmlProperty(const QDomElement &producer, const QString &propertyName, const QString &defaultValue)
 {
     QString value = defaultValue;
     QDomNodeList props = producer.elementsByTagName(QStringLiteral("property"));
     for (int i = 0; i < props.count(); ++i) {
         if (props.at(i).toElement().attribute(QStringLiteral("name")) == propertyName) {
             value = props.at(i).firstChild().nodeValue();
             break;
         }
     }
     return value;
 }
 
 void ProjectClip::updateAudioThumbnail(QVariantList audioLevels)
 {
     std::swap(audioFrameCache, audioLevels); // avoid second copy
     m_audioThumbCreated = true;
     if (auto ptr = m_model.lock()) {
         emit std::static_pointer_cast<ProjectItemModel>(ptr)->refreshAudioThumbs(m_binId);
     }
     updateTimelineClips({TimelineModel::AudioLevelsRole});
 }
 
 bool ProjectClip::audioThumbCreated() const
 {
     return (m_audioThumbCreated);
 }
 
 ClipType::ProducerType ProjectClip::clipType() const
 {
     return m_clipType;
 }
 
 bool ProjectClip::hasParent(const QString &id) const
 {
     std::shared_ptr<AbstractProjectItem> par = parent();
     while (par) {
         if (par->clipId() == id) {
             return true;
         }
         par = par->parent();
     }
     return false;
 }
 
 std::shared_ptr<ProjectClip> ProjectClip::clip(const QString &id)
 {
     if (id == m_binId) {
         return std::static_pointer_cast<ProjectClip>(shared_from_this());
     }
     return std::shared_ptr<ProjectClip>();
 }
 
 std::shared_ptr<ProjectFolder> ProjectClip::folder(const QString &id)
 {
     Q_UNUSED(id)
     return std::shared_ptr<ProjectFolder>();
 }
 
 std::shared_ptr<ProjectSubClip> ProjectClip::getSubClip(int in, int out)
 {
     for (int i = 0; i < childCount(); ++i) {
         std::shared_ptr<ProjectSubClip> clip = std::static_pointer_cast<ProjectSubClip>(child(i))->subClip(in, out);
         if (clip) {
             return clip;
         }
     }
     return std::shared_ptr<ProjectSubClip>();
 }
 
 QStringList ProjectClip::subClipIds() const
 {
     QStringList subIds;
     for (int i = 0; i < childCount(); ++i) {
         std::shared_ptr<AbstractProjectItem> clip = std::static_pointer_cast<AbstractProjectItem>(child(i));
         if (clip) {
             subIds << clip->clipId();
         }
     }
     return subIds;
 }
 
 std::shared_ptr<ProjectClip> ProjectClip::clipAt(int ix)
 {
     if (ix == row()) {
         return std::static_pointer_cast<ProjectClip>(shared_from_this());
     }
     return std::shared_ptr<ProjectClip>();
 }
 
 /*bool ProjectClip::isValid() const
 {
     return m_controller->isValid();
 }*/
 
 bool ProjectClip::hasUrl() const
 {
     if ((m_clipType != ClipType::Color) && (m_clipType != ClipType::Unknown)) {
         return (!clipUrl().isEmpty());
     }
     return false;
 }
 
 const QString ProjectClip::url() const
 {
     return clipUrl();
 }
 
 GenTime ProjectClip::duration() const
 {
     return getPlaytime();
 }
 
 size_t ProjectClip::frameDuration() const
 {
     GenTime d = duration();
     return (size_t)d.frames(pCore->getCurrentFps());
 }
 
 void ProjectClip::reloadProducer(bool refreshOnly)
 {
     // we find if there are some loading job on that clip
     int loadjobId = -1;
     pCore->jobManager()->hasPendingJob(clipId(), AbstractClipJob::LOADJOB, &loadjobId);
     QMutexLocker lock(&m_thumbMutex);
     if (refreshOnly) {
         // In that case, we only want a new thumbnail.
         // We thus set up a thumb job. We must make sure that there is no pending LOADJOB
         // Clear cache first
         ThumbnailCache::get()->invalidateThumbsForClip(clipId());
         pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::THUMBJOB);
         m_thumbsProducer.reset();
         pCore->jobManager()->startJob<ThumbJob>({clipId()}, loadjobId, QString(), 150, -1, true, true);
 
     } else {
         // If another load job is running?
         if (loadjobId > -1) {
             pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::LOADJOB);
         }
         QDomDocument doc;
         QDomElement xml = toXml(doc);
         if (!xml.isNull()) {
             pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::THUMBJOB);
             m_thumbsProducer.reset();
             ThumbnailCache::get()->invalidateThumbsForClip(clipId());
             int loadJob = pCore->jobManager()->startJob<LoadJob>({clipId()}, loadjobId, QString(), xml);
             pCore->jobManager()->startJob<ThumbJob>({clipId()}, loadJob, QString(), 150, -1, true, true);
         }
     }
 }
 
 QDomElement ProjectClip::toXml(QDomDocument &document, bool includeMeta)
 {
     getProducerXML(document, includeMeta);
     QDomElement prod = document.documentElement().firstChildElement(QStringLiteral("producer"));
     if (m_clipType != ClipType::Unknown) {
         prod.setAttribute(QStringLiteral("type"), (int)m_clipType);
     }
     return prod;
 }
 
 void ProjectClip::setThumbnail(const QImage &img)
 {
     QPixmap thumb = roundedPixmap(QPixmap::fromImage(img));
     if (hasProxy() && !thumb.isNull()) {
         // Overlay proxy icon
         QPainter p(&thumb);
         QColor c(220, 220, 10, 200);
         QRect r(0, 0, thumb.height() / 2.5, thumb.height() / 2.5);
         p.fillRect(r, c);
         QFont font = p.font();
         font.setPixelSize(r.height());
         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"));
     }
     m_thumbnail = QIcon(thumb);
     if (auto ptr = m_model.lock()) {
         std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                        AbstractProjectItem::DataThumbnail);
     }
 }
 
 bool ProjectClip::hasAudioAndVideo() const
 {
     return hasAudio() && hasVideo() && m_masterProducer->get_int("set.test_image") == 0 && m_masterProducer->get_int("set.test_audio") == 0;
 }
 
 bool ProjectClip::isCompatible(PlaylistState::ClipState state) const
 {
     switch (state) {
     case PlaylistState::AudioOnly:
         return hasAudio() && (m_masterProducer->get_int("set.test_audio") == 0);
     case PlaylistState::VideoOnly:
         return hasVideo() && (m_masterProducer->get_int("set.test_image") == 0);
     default:
         return true;
     }
 }
 
 QPixmap ProjectClip::thumbnail(int width, int height)
 {
     return m_thumbnail.pixmap(width, height);
 }
 
 bool ProjectClip::setProducer(std::shared_ptr<Mlt::Producer> producer, bool replaceProducer)
 {
     Q_UNUSED(replaceProducer)
     qDebug() << "################### ProjectClip::setproducer";
     QMutexLocker locker(&m_producerMutex);
     updateProducer(std::move(producer));
     m_thumbsProducer.reset();
     connectEffectStack();
 
     // Update info
     if (m_name.isEmpty()) {
         m_name = clipName();
     }
     m_date = date;
     m_description = ClipController::description();
     m_temporaryUrl.clear();
     if (m_clipType == ClipType::Audio) {
         m_thumbnail = QIcon::fromTheme(QStringLiteral("audio-x-generic"));
     } else if (m_clipType == ClipType::Image) {
         if (producer->get_int("meta.media.width") < 8 || producer->get_int("meta.media.height") < 8) {
             KMessageBox::information(QApplication::activeWindow(),
                                      i18n("Image dimension smaller than 8 pixels.\nThis is not correctly supported by our video framework."));
         }
     }
     m_duration = getStringDuration();
     m_clipStatus = StatusReady;
     if (!hasProxy()) {
         if (auto ptr = m_model.lock()) emit std::static_pointer_cast<ProjectItemModel>(ptr)->refreshPanel(m_binId);
     }
     if (auto ptr = m_model.lock()) {
         std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                        AbstractProjectItem::DataDuration);
         std::static_pointer_cast<ProjectItemModel>(ptr)->updateWatcher(std::static_pointer_cast<ProjectClip>(shared_from_this()));
     }
     // Make sure we have a hash for this clip
     getFileHash();
     // set parent again (some info need to be stored in producer)
     updateParent(parentItem().lock());
 
     if (pCore->currentDoc()->getDocumentProperty(QStringLiteral("enableproxy")).toInt() == 1) {
         QList<std::shared_ptr<ProjectClip>> clipList;
         // automatic proxy generation enabled
         if (m_clipType == ClipType::Image && pCore->currentDoc()->getDocumentProperty(QStringLiteral("generateimageproxy")).toInt() == 1) {
             if (getProducerIntProperty(QStringLiteral("meta.media.width")) >= KdenliveSettings::proxyimageminsize() &&
                 getProducerProperty(QStringLiteral("kdenlive:proxy")) == QStringLiteral()) {
                 clipList << std::static_pointer_cast<ProjectClip>(shared_from_this());
             }
         } else if (pCore->currentDoc()->getDocumentProperty(QStringLiteral("generateproxy")).toInt() == 1 &&
                    (m_clipType == ClipType::AV || m_clipType == ClipType::Video) && getProducerProperty(QStringLiteral("kdenlive:proxy")) == QStringLiteral()) {
             bool skipProducer = false;
             if (pCore->currentDoc()->getDocumentProperty(QStringLiteral("enableexternalproxy")).toInt() == 1) {
                 QStringList externalParams = pCore->currentDoc()->getDocumentProperty(QStringLiteral("externalproxyparams")).split(QLatin1Char(';'));
                 // We have a camcorder profile, check if we have opened a proxy clip
                 if (externalParams.count() >= 6) {
                     QFileInfo info(m_path);
                     QDir dir = info.absoluteDir();
                     dir.cd(externalParams.at(3));
                     QString fileName = info.fileName();
                     if (!externalParams.at(2).isEmpty()) {
                         fileName.chop(externalParams.at(2).size());
                     }
                     fileName.append(externalParams.at(5));
                     if (dir.exists(fileName)) {
                         setProducerProperty(QStringLiteral("kdenlive:proxy"), m_path);
                         m_path = dir.absoluteFilePath(fileName);
                         setProducerProperty(QStringLiteral("kdenlive:originalurl"), m_path);
                         getFileHash();
                         skipProducer = true;
                     }
                 }
             }
             if (!skipProducer && getProducerIntProperty(QStringLiteral("meta.media.width")) >= KdenliveSettings::proxyminsize()) {
                 clipList << std::static_pointer_cast<ProjectClip>(shared_from_this());
             }
         }
         if (!clipList.isEmpty()) {
             pCore->currentDoc()->slotProxyCurrentItem(true, clipList, false);
         }
     }
     pCore->bin()->reloadMonitorIfActive(clipId());
     for (auto &p : m_audioProducers) {
         m_effectStack->removeService(p.second);
     }
     for (auto &p : m_videoProducers) {
         m_effectStack->removeService(p.second);
     }
     for (auto &p : m_timewarpProducers) {
         m_effectStack->removeService(p.second);
     }
     // Release audio producers
     m_audioProducers.clear();
     m_videoProducers.clear();
     m_timewarpProducers.clear();
     emit refreshPropertiesPanel();
     replaceInTimeline();
     return true;
 }
 
 std::shared_ptr<Mlt::Producer> ProjectClip::thumbProducer()
 {
     if (m_thumbsProducer) {
         return m_thumbsProducer;
     }
     if (clipType() == ClipType::Unknown) {
         return nullptr;
     }
     QMutexLocker lock(&m_thumbMutex);
     std::shared_ptr<Mlt::Producer> prod = originalProducer();
     if (!prod->is_valid()) {
         return nullptr;
     }
     if (KdenliveSettings::gpu_accel()) {
         // TODO: when the original producer changes, we must reload this thumb producer
         m_thumbsProducer = softClone(ClipController::getPassPropertiesList());
         Mlt::Filter converter(*prod->profile(), "avcolor_space");
         m_thumbsProducer->attach(converter);
     } else {
         QString mltService = m_masterProducer->get("mlt_service");
         const QString mltResource = m_masterProducer->get("resource");
         if (mltService == QLatin1String("avformat")) {
             mltService = QStringLiteral("avformat-novalidate");
         }
         m_thumbsProducer.reset(new Mlt::Producer(*pCore->thumbProfile(), mltService.toUtf8().constData(), mltResource.toUtf8().constData()));
         if (m_thumbsProducer->is_valid()) {
             Mlt::Properties original(m_masterProducer->get_properties());
             Mlt::Properties cloneProps(m_thumbsProducer->get_properties());
             cloneProps.pass_list(original, ClipController::getPassPropertiesList());
             Mlt::Filter scaler(*pCore->thumbProfile(), "swscale");
             Mlt::Filter padder(*pCore->thumbProfile(), "resize");
             Mlt::Filter converter(*pCore->thumbProfile(), "avcolor_space");
             m_thumbsProducer->set("audio_index", -1);
             m_thumbsProducer->attach(scaler);
             m_thumbsProducer->attach(padder);
             m_thumbsProducer->attach(converter);
         }
     }
     return m_thumbsProducer;
 }
 
 void ProjectClip::createDisabledMasterProducer()
 {
     if (!m_disabledProducer) {
         m_disabledProducer = cloneProducer(&pCore->getCurrentProfile()->profile());
         m_disabledProducer->set("set.test_audio", 1);
         m_disabledProducer->set("set.test_image", 1);
         m_effectStack->addService(m_disabledProducer);
     }
 }
 std::shared_ptr<Mlt::Producer> ProjectClip::getTimelineProducer(int clipId, PlaylistState::ClipState state, double speed)
 {
     if (!m_masterProducer) {
         return nullptr;
     }
     if (qFuzzyCompare(speed, 1.0)) {
         // we are requesting a normal speed producer
         // We can first cleen the speed producers we have for the current id
         if (m_timewarpProducers.count(clipId) > 0) {
             m_effectStack->removeService(m_timewarpProducers[clipId]);
             m_timewarpProducers.erase(clipId);
         }
         if (state == PlaylistState::AudioOnly) {
             // We need to get an audio producer, if none exists
             if (m_audioProducers.count(clipId) == 0) {
                 m_audioProducers[clipId] = cloneProducer(&pCore->getCurrentProfile()->profile(), true);
                 m_audioProducers[clipId]->set("set.test_audio", 0);
                 m_audioProducers[clipId]->set("set.test_image", 1);
                 m_effectStack->addService(m_audioProducers[clipId]);
             }
             return std::shared_ptr<Mlt::Producer>(m_audioProducers[clipId]->cut());
         }
         if (m_audioProducers.count(clipId) > 0) {
             m_effectStack->removeService(m_audioProducers[clipId]);
             m_audioProducers.erase(clipId);
         }
         if (state == PlaylistState::VideoOnly) {
             // we return the video producer
             // We need to get an audio producer, if none exists
             if (m_clipType == ClipType::Color || m_clipType == ClipType::Image || m_clipType == ClipType::Text) {
                 int duration = m_masterProducer->time_to_frames(m_masterProducer->get("kdenlive:duration"));
                 return std::shared_ptr<Mlt::Producer>(m_masterProducer->cut(-1, duration > 0 ? duration : -1));
             }
             if (m_videoProducers.count(clipId) == 0) {
                 m_videoProducers[clipId] = cloneProducer(&pCore->getCurrentProfile()->profile(), true);
                 m_videoProducers[clipId]->set("set.test_audio", 1);
                 m_videoProducers[clipId]->set("set.test_image", 0);
                 m_effectStack->addService(m_videoProducers[clipId]);
             }
             int duration = m_masterProducer->time_to_frames(m_masterProducer->get("kdenlive:duration"));
             return std::shared_ptr<Mlt::Producer>(m_videoProducers[clipId]->cut(-1, duration > 0 ? duration : -1));
         }
         if (m_videoProducers.count(clipId) > 0) {
             m_effectStack->removeService(m_videoProducers[clipId]);
             m_videoProducers.erase(clipId);
         }
         Q_ASSERT(state == PlaylistState::Disabled);
         createDisabledMasterProducer();
         int duration = m_masterProducer->time_to_frames(m_masterProducer->get("kdenlive:duration"));
         return std::shared_ptr<Mlt::Producer>(m_disabledProducer->cut(-1, duration > 0 ? duration : -1));
     }
 
     // in that case, we need to create a warp producer, if we don't have one
     if (m_audioProducers.count(clipId) > 0) {
         m_effectStack->removeService(m_audioProducers[clipId]);
         m_audioProducers.erase(clipId);
     }
     if (m_videoProducers.count(clipId) > 0) {
         m_effectStack->removeService(m_videoProducers[clipId]);
         m_videoProducers.erase(clipId);
     }
 
     std::shared_ptr<Mlt::Producer> warpProducer;
     if (m_timewarpProducers.count(clipId) > 0) {
         // remove in all cases, we add it unconditionally anyways
         m_effectStack->removeService(m_timewarpProducers[clipId]);
         if (qFuzzyCompare(m_timewarpProducers[clipId]->get_double("warp_speed"), speed)) {
             // the producer we have is good, use it !
             warpProducer = m_timewarpProducers[clipId];
             qDebug() << "Reusing producer!";
         } else {
             m_timewarpProducers.erase(clipId);
         }
     }
     if (!warpProducer) {
         QLocale locale;
         QString resource(originalProducer()->get("resource"));
         if (resource.isEmpty() || resource == QLatin1String("<producer>")) {
             resource = m_service;
         }
         QString url = QString("timewarp:%1:%2").arg(locale.toString(speed)).arg(resource);
         warpProducer.reset(new Mlt::Producer(*originalProducer()->profile(), url.toUtf8().constData()));
         qDebug() << "new producer: " << url;
         qDebug() << "warp LENGTH before" << warpProducer->get_length();
         int original_length = originalProducer()->get_length();
         // this is a workaround to cope with Mlt erroneous rounding
         warpProducer->set("length", double(original_length) / speed);
     }
 
     qDebug() << "warp LENGTH" << warpProducer->get_length();
     warpProducer->set("set.test_audio", 1);
     warpProducer->set("set.test_image", 1);
     if (state == PlaylistState::AudioOnly) {
         warpProducer->set("set.test_audio", 0);
     }
     if (state == PlaylistState::VideoOnly) {
         warpProducer->set("set.test_image", 0);
     }
     m_timewarpProducers[clipId] = warpProducer;
     m_effectStack->addService(m_timewarpProducers[clipId]);
     return std::shared_ptr<Mlt::Producer>(warpProducer->cut());
 }
 
 std::pair<std::shared_ptr<Mlt::Producer>, bool> ProjectClip::giveMasterAndGetTimelineProducer(int clipId, std::shared_ptr<Mlt::Producer> master,
                                                                                               PlaylistState::ClipState state)
 {
     int in = master->get_in();
     int out = master->get_out();
     if (master->parent().is_valid()) {
         // in that case, we have a cut
         // check whether it's a timewarp
         double speed = 1.0;
         bool timeWarp = false;
         if (QString::fromUtf8(master->parent().get("mlt_service")) == QLatin1String("timewarp")) {
             speed = master->parent().get_double("warp_speed");
             timeWarp = true;
         }
         if (master->parent().get_int("_loaded") == 1) {
             // we already have a clip that shares the same master
 
             if (state != PlaylistState::Disabled || timeWarp) {
                 // In that case, we must create copies
                 std::shared_ptr<Mlt::Producer> prod(getTimelineProducer(clipId, state, speed)->cut(in, out));
                 return {prod, false};
             }
             if (state == PlaylistState::Disabled && !m_disabledProducer) {
                 qDebug() << "Warning: weird, we found a disabled clip whose master is already loaded but we don't have any yet";
                 createDisabledMasterProducer();
                 return {std::shared_ptr<Mlt::Producer>(m_disabledProducer->cut(in, out)), false};
             }
             if (state == PlaylistState::Disabled && QString::fromUtf8(m_disabledProducer->get("id")) != QString::fromUtf8(master->parent().get("id"))) {
                 qDebug() << "Warning: weird, we found a disabled clip whose master is already loaded but doesn't match ours";
                 return {std::shared_ptr<Mlt::Producer>(m_disabledProducer->cut(in, out)), false};
             }
             // We have a good id, this clip can be used
             return {master, true};
         } else {
             master->parent().set("_loaded", 1);
             if (timeWarp) {
                 m_timewarpProducers[clipId] = std::shared_ptr<Mlt::Producer>(new Mlt::Producer(&master->parent()));
                 m_effectStack->loadService(m_timewarpProducers[clipId]);
                 return {master, true};
             }
             if (state == PlaylistState::AudioOnly) {
                 m_audioProducers[clipId] = std::shared_ptr<Mlt::Producer>(new Mlt::Producer(&master->parent()));
                 m_effectStack->loadService(m_audioProducers[clipId]);
                 return {master, true};
             }
             if (state == PlaylistState::VideoOnly) {
                 // good, we found a master video producer, and we didn't have any
                 m_videoProducers[clipId] = std::shared_ptr<Mlt::Producer>(new Mlt::Producer(&master->parent()));
                 m_effectStack->loadService(m_videoProducers[clipId]);
                 return {master, true};
             }
             if (state == PlaylistState::Disabled && !m_disabledProducer) {
                 // good, we found a master disabled producer, and we didn't have any
                 m_disabledProducer.reset(master->parent().cut());
                 m_effectStack->loadService(m_disabledProducer);
                 return {master, true};
             }
             qDebug() << "Warning: weird, we found a clip whose master is not loaded but we already have a master";
             Q_ASSERT(false);
         }
     } else if (master->is_valid()) {
         // in that case, we have a master
         qDebug() << "Warning: weird, we received a master clip in lieue of a cut";
         double speed = 1.0;
         if (QString::fromUtf8(master->parent().get("mlt_service")) == QLatin1String("timewarp")) {
             speed = master->get_double("warp_speed");
         }
         return {getTimelineProducer(clipId, state, speed), false};
     }
     // we have a problem
     return {std::shared_ptr<Mlt::Producer>(ClipController::mediaUnavailable->cut()), false};
 }
 /*
 std::shared_ptr<Mlt::Producer> ProjectClip::timelineProducer(PlaylistState::ClipState state, int track)
 {
     if (!m_service.startsWith(QLatin1String("avformat"))) {
         std::shared_ptr<Mlt::Producer> prod(originalProducer()->cut());
         int length = getProducerIntProperty(QStringLiteral("kdenlive:duration"));
         if (length > 0) {
             prod->set_in_and_out(0, length);
         }
         return prod;
     }
     if (state == PlaylistState::VideoOnly) {
         if (m_timelineProducers.count(0) > 0) {
             return std::shared_ptr<Mlt::Producer>(m_timelineProducers.find(0)->second->cut());
         }
         std::shared_ptr<Mlt::Producer> videoProd = cloneProducer();
         videoProd->set("audio_index", -1);
         m_timelineProducers[0] = videoProd;
         return std::shared_ptr<Mlt::Producer>(videoProd->cut());
     }
     if (state == PlaylistState::AudioOnly) {
         if (m_timelineProducers.count(-track) > 0) {
             return std::shared_ptr<Mlt::Producer>(m_timelineProducers.find(-track)->second->cut());
         }
         std::shared_ptr<Mlt::Producer> audioProd = cloneProducer();
         audioProd->set("video_index", -1);
         m_timelineProducers[-track] = audioProd;
         return std::shared_ptr<Mlt::Producer>(audioProd->cut());
     }
     if (m_timelineProducers.count(track) > 0) {
         return std::shared_ptr<Mlt::Producer>(m_timelineProducers.find(track)->second->cut());
     }
     std::shared_ptr<Mlt::Producer> normalProd = cloneProducer();
     m_timelineProducers[track] = normalProd;
     return std::shared_ptr<Mlt::Producer>(normalProd->cut());
 }*/
 
 std::shared_ptr<Mlt::Producer> ProjectClip::cloneProducer(Mlt::Profile *destProfile, bool removeEffects)
 {
     Mlt::Profile master_profile(mlt_profile_clone(m_masterProducer->get_profile()));
     Mlt::Consumer c(master_profile, "xml", "string");
     Mlt::Service s(m_masterProducer->get_service());
     int ignore = s.get_int("ignore_points");
     if (ignore) {
         s.set("ignore_points", 0);
     }
     c.connect(s);
     c.set("time_format", "frames");
     c.set("no_meta", 1);
     c.set("no_root", 1);
     c.set("no_profile", 1);
     c.set("root", "/");
     c.set("store", "kdenlive");
-    c.start();
+    c.run();
     if (ignore) {
         s.set("ignore_points", ignore);
     }
     const QByteArray clipXml = c.get("string");
+    c.stop();
+    c.purge();
     std::shared_ptr<Mlt::Producer> prod;
     prod.reset(new Mlt::Producer(destProfile ? *destProfile : master_profile, "xml-string", clipXml.constData()));
     if (strcmp(prod->get("mlt_service"), "avformat") == 0) {
         prod->set("mlt_service", "avformat-novalidate");
     }
     if (removeEffects) {
         int ct = 0;
         Mlt::Filter *filter = prod->filter(ct);
         while (filter) {
             qDebug() << "// EFFECT " << ct << " : " << filter->get("mlt_service");
             QString ix = QString::fromLatin1(filter->get("kdenlive_id"));
             if (!ix.isEmpty()) {
                 qDebug() << "/ + + DELTING";
                 if (prod->detach(*filter) == 0) {
                 } else {
                     ct++;
                 }
             } else {
                 ct++;
             }
             delete filter;
             filter = prod->filter(ct);
         }
     }
     prod->set("id", (char *)nullptr);
     return prod;
 }
 
 std::shared_ptr<Mlt::Producer> ProjectClip::cloneProducer(std::shared_ptr<Mlt::Producer> producer)
 {
     Mlt::Consumer c(*producer->profile(), "xml", "string");
     Mlt::Service s(producer->get_service());
     int ignore = s.get_int("ignore_points");
     if (ignore) {
         s.set("ignore_points", 0);
     }
     c.connect(s);
     c.set("time_format", "frames");
     c.set("no_meta", 1);
     c.set("no_root", 1);
     c.set("no_profile", 1);
     c.set("root", "/");
     c.set("store", "kdenlive");
     c.start();
     if (ignore) {
         s.set("ignore_points", ignore);
     }
     const QByteArray clipXml = c.get("string");
     std::shared_ptr<Mlt::Producer> prod(new Mlt::Producer(*producer->profile(), "xml-string", clipXml.constData()));
     if (strcmp(prod->get("mlt_service"), "avformat") == 0) {
         prod->set("mlt_service", "avformat-novalidate");
     }
     return prod;
 }
 
 std::shared_ptr<Mlt::Producer> ProjectClip::softClone(const char *list)
 {
     QString service = QString::fromLatin1(m_masterProducer->get("mlt_service"));
     QString resource = QString::fromLatin1(m_masterProducer->get("resource"));
     std::shared_ptr<Mlt::Producer> clone(new Mlt::Producer(*m_masterProducer->profile(), service.toUtf8().constData(), resource.toUtf8().constData()));
     Mlt::Properties original(m_masterProducer->get_properties());
     Mlt::Properties cloneProps(clone->get_properties());
     cloneProps.pass_list(original, list);
     return clone;
 }
 
 bool ProjectClip::isReady() const
 {
     return m_clipStatus == StatusReady;
 }
 
 /*void ProjectClip::setZone(const QPoint &zone)
 {
     m_zone = zone;
 }*/
 
 QPoint ProjectClip::zone() const
 {
     int x = getProducerIntProperty(QStringLiteral("kdenlive:zone_in"));
     int y = getProducerIntProperty(QStringLiteral("kdenlive:zone_out"));
     if (y <= x) {
         y = getFramePlaytime();
     }
     return QPoint(x, y);
 }
 
 const QString ProjectClip::hash()
 {
     QString clipHash = getProducerProperty(QStringLiteral("kdenlive:file_hash"));
     if (!clipHash.isEmpty()) {
         return clipHash;
     }
     return getFileHash();
 }
 
 const QString ProjectClip::getFileHash()
 {
     QByteArray fileData;
     QByteArray fileHash;
     switch (m_clipType) {
     case ClipType::SlideShow:
         fileData = clipUrl().toUtf8();
         fileHash = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
         break;
     case ClipType::Text:
     case ClipType::TextTemplate:
         fileData = getProducerProperty(QStringLiteral("xmldata")).toUtf8();
         fileHash = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
         break;
     case ClipType::QText:
         fileData = getProducerProperty(QStringLiteral("text")).toUtf8();
         fileHash = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
         break;
     case ClipType::Color:
         fileData = getProducerProperty(QStringLiteral("resource")).toUtf8();
         fileHash = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
         break;
     default:
         QFile file(clipUrl());
         if (file.open(QIODevice::ReadOnly)) { // write size and hash only if resource points to a file
             /*
              * 1 MB = 1 second per 450 files (or faster)
              * 10 MB = 9 seconds per 450 files (or faster)
              */
             if (file.size() > 2000000) {
                 fileData = file.read(1000000);
                 if (file.seek(file.size() - 1000000)) {
                     fileData.append(file.readAll());
                 }
             } else {
                 fileData = file.readAll();
             }
             file.close();
             ClipController::setProducerProperty(QStringLiteral("kdenlive:file_size"), QString::number(file.size()));
             fileHash = QCryptographicHash::hash(fileData, QCryptographicHash::Md5);
         }
         break;
     }
     if (fileHash.isEmpty()) {
         qDebug() << "// WARNING EMPTY CLIP HASH: ";
         return QString();
     }
     QString result = fileHash.toHex();
     ClipController::setProducerProperty(QStringLiteral("kdenlive:file_hash"), result);
     return result;
 }
 
 double ProjectClip::getOriginalFps() const
 {
     return originalFps();
 }
 
 bool ProjectClip::hasProxy() const
 {
     QString proxy = getProducerProperty(QStringLiteral("kdenlive:proxy"));
     return proxy.size() > 2;
 }
 
 void ProjectClip::setProperties(const QMap<QString, QString> &properties, bool refreshPanel)
 {
     qDebug() << "// SETTING CLIP PROPERTIES: " << properties;
     QMapIterator<QString, QString> i(properties);
     QMap<QString, QString> passProperties;
     bool refreshAnalysis = false;
     bool reload = false;
     bool refreshOnly = true;
     if (properties.contains(QStringLiteral("templatetext"))) {
         m_description = properties.value(QStringLiteral("templatetext"));
         if (auto ptr = m_model.lock())
             std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                            AbstractProjectItem::ClipStatus);
         refreshPanel = true;
     }
     // Some properties also need to be passed to track producers
     QStringList timelineProperties{QStringLiteral("force_aspect_ratio"),  QStringLiteral("video_index"), QStringLiteral("audio_index"),
                                    QStringLiteral("set.force_full_luma"), QStringLiteral("full_luma"),   QStringLiteral("threads"),
                                    QStringLiteral("force_colorspace"),    QStringLiteral("force_tff"),   QStringLiteral("force_progressive"),
                                    QStringLiteral("video_index"),         QStringLiteral("audio_index")};
     QStringList forceReloadProperties{QStringLiteral("autorotate"), QStringLiteral("templatetext"),   QStringLiteral("resource"),
                                       QStringLiteral("force_fps"),  QStringLiteral("set.test_image"), QStringLiteral("set.test_audio")};
     QStringList keys{QStringLiteral("luma_duration"), QStringLiteral("luma_file"), QStringLiteral("fade"),     QStringLiteral("ttl"),
                      QStringLiteral("softness"),      QStringLiteral("crop"),      QStringLiteral("animation")};
     QVector<int> updateRoles;
     while (i.hasNext()) {
         i.next();
         setProducerProperty(i.key(), i.value());
         if (m_clipType == ClipType::SlideShow && keys.contains(i.key())) {
             reload = true;
             refreshOnly = false;
         }
         if (i.key().startsWith(QLatin1String("kdenlive:clipanalysis"))) {
             refreshAnalysis = true;
         }
         if (timelineProperties.contains(i.key())) {
             passProperties.insert(i.key(), i.value());
         }
     }
     if (properties.contains(QStringLiteral("kdenlive:proxy"))) {
         QString value = properties.value(QStringLiteral("kdenlive:proxy"));
         // If value is "-", that means user manually disabled proxy on this clip
         if (value.isEmpty() || value == QLatin1String("-")) {
             // reset proxy
             int id;
             if (pCore->jobManager()->hasPendingJob(clipId(), AbstractClipJob::PROXYJOB, &id)) {
                 // The proxy clip is being created, abort
                 pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::PROXYJOB);
             } else {
                 reload = true;
                 refreshOnly = false;
             }
         } else {
             // A proxy was requested, make sure to keep original url
             setProducerProperty(QStringLiteral("kdenlive:originalurl"), url());
             pCore->jobManager()->startJob<ProxyJob>({clipId()}, -1, QString());
         }
     } else if (!reload) {
         const QList<QString> propKeys = properties.keys();
         for (const QString &k : propKeys) {
             if (forceReloadProperties.contains(k)) {
                 if (m_clipType != ClipType::Color) {
                     reload = true;
                     refreshOnly = false;
                 } else {
                     // Clip resource changed, update thumbnail
                     reload = true;
                     refreshPanel = true;
                     updateRoles << TimelineModel::ResourceRole;
                 }
                 break;
             }
         }
     }
     if (!reload && (properties.contains(QStringLiteral("xmldata")) || !passProperties.isEmpty())) {
         reload = true;
     }
     if (refreshAnalysis) {
         emit refreshAnalysisPanel();
     }
     if (properties.contains(QStringLiteral("length")) || properties.contains(QStringLiteral("kdenlive:duration"))) {
         m_duration = getStringDuration();
         if (auto ptr = m_model.lock())
             std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                            AbstractProjectItem::DataDuration);
         refreshOnly = false;
         reload = true;
     }
 
     if (properties.contains(QStringLiteral("kdenlive:clipname"))) {
         m_name = properties.value(QStringLiteral("kdenlive:clipname"));
         refreshPanel = true;
         if (auto ptr = m_model.lock()) {
             std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<ProjectClip>(shared_from_this()),
                                                                            AbstractProjectItem::DataName);
         }
         // update timeline clips
         updateTimelineClips(QVector<int>() << TimelineModel::NameRole);
     }
     if (refreshPanel) {
         // Some of the clip properties have changed through a command, update properties panel
         emit refreshPropertiesPanel();
     }
     if (reload) {
         // producer has changed, refresh monitor and thumbnail
         if (hasProxy()) {
             pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::PROXYJOB);
             setProducerProperty(QStringLiteral("_overwriteproxy"), 1);
             pCore->jobManager()->startJob<ProxyJob>({clipId()}, -1, QString());
         } else {
             reloadProducer(refreshOnly);
         }
         if (refreshOnly) {
             if (auto ptr = m_model.lock()) {
                 emit std::static_pointer_cast<ProjectItemModel>(ptr)->refreshClip(m_binId);
             }
         }
         if (!updateRoles.isEmpty()) {
             updateTimelineClips(updateRoles);
         }
     }
     if (!passProperties.isEmpty()) {
         if (auto ptr = m_model.lock()) emit std::static_pointer_cast<ProjectItemModel>(ptr)->updateTimelineProducers(m_binId, passProperties);
     }
 }
 
 ClipPropertiesController *ProjectClip::buildProperties(QWidget *parent)
 {
     auto ptr = m_model.lock();
     Q_ASSERT(ptr);
     ClipPropertiesController *panel = new ClipPropertiesController(static_cast<ClipController *>(this), parent);
     connect(this, &ProjectClip::refreshPropertiesPanel, panel, &ClipPropertiesController::slotReloadProperties);
     connect(this, &ProjectClip::refreshAnalysisPanel, panel, &ClipPropertiesController::slotFillAnalysisData);
     connect(panel, &ClipPropertiesController::requestProxy, [this](bool doProxy) {
         QList<std::shared_ptr<ProjectClip>> clipList{std::static_pointer_cast<ProjectClip>(shared_from_this())};
         pCore->currentDoc()->slotProxyCurrentItem(doProxy, clipList);
     });
     connect(panel, &ClipPropertiesController::deleteProxy, this, &ProjectClip::deleteProxy);
     return panel;
 }
 
 void ProjectClip::deleteProxy()
 {
     // Disable proxy file
     QString proxy = getProducerProperty(QStringLiteral("kdenlive:proxy"));
     QList<std::shared_ptr<ProjectClip>> clipList{std::static_pointer_cast<ProjectClip>(shared_from_this())};
     pCore->currentDoc()->slotProxyCurrentItem(false, clipList);
     // Delete
     bool ok;
     QDir dir = pCore->currentDoc()->getCacheDir(CacheProxy, &ok);
     if (ok && proxy.length() > 2) {
         proxy = QFileInfo(proxy).fileName();
         if (dir.exists(proxy)) {
             dir.remove(proxy);
         }
     }
 }
 
 void ProjectClip::updateParent(std::shared_ptr<TreeItem> parent)
 {
     if (parent) {
         auto item = std::static_pointer_cast<AbstractProjectItem>(parent);
         ClipController::setProducerProperty(QStringLiteral("kdenlive:folderid"), item->clipId());
     }
     AbstractProjectItem::updateParent(parent);
 }
 
 bool ProjectClip::matches(const QString &condition)
 {
     // TODO
     Q_UNUSED(condition)
     return true;
 }
 
 bool ProjectClip::rename(const QString &name, int column)
 {
     QMap<QString, QString> newProperites;
     QMap<QString, QString> oldProperites;
     bool edited = false;
     switch (column) {
     case 0:
         if (m_name == name) {
             return false;
         }
         // Rename clip
         oldProperites.insert(QStringLiteral("kdenlive:clipname"), m_name);
         newProperites.insert(QStringLiteral("kdenlive:clipname"), name);
         m_name = name;
         edited = true;
         break;
     case 2:
         if (m_description == name) {
             return false;
         }
         // Rename clip
         if (m_clipType == ClipType::TextTemplate) {
             oldProperites.insert(QStringLiteral("templatetext"), m_description);
             newProperites.insert(QStringLiteral("templatetext"), name);
         } else {
             oldProperites.insert(QStringLiteral("kdenlive:description"), m_description);
             newProperites.insert(QStringLiteral("kdenlive:description"), name);
         }
         m_description = name;
         edited = true;
         break;
     }
     if (edited) {
         pCore->bin()->slotEditClipCommand(m_binId, oldProperites, newProperites);
     }
     return edited;
 }
 
 QVariant ProjectClip::getData(DataType type) const
 {
     switch (type) {
     case AbstractProjectItem::IconOverlay:
         return m_effectStack && m_effectStack->rowCount() > 0 ? QVariant("kdenlive-track_has_effect") : QVariant();
     default:
         return AbstractProjectItem::getData(type);
     }
 }
 
 void ProjectClip::slotExtractImage(const QList<int> &frames)
 {
     QMutexLocker lock(&m_thumbMutex);
     for (int i = 0; i < frames.count(); i++) {
         if (!m_requestedThumbs.contains(frames.at(i))) {
             m_requestedThumbs << frames.at(i);
         }
     }
     qSort(m_requestedThumbs);
     if (!m_thumbThread.isRunning()) {
         m_thumbThread = QtConcurrent::run(this, &ProjectClip::doExtractImage);
     }
 }
 
 void ProjectClip::doExtractImage()
 {
     // TODO refac: we can probably move that into a ThumbJob
     std::shared_ptr<Mlt::Producer> prod = thumbProducer();
     if (prod == nullptr || !prod->is_valid()) {
         return;
     }
     int frameWidth = 150 * prod->profile()->dar() + 0.5;
     bool ok = false;
     auto ptr = m_model.lock();
     Q_ASSERT(ptr);
     QDir thumbFolder = pCore->currentDoc()->getCacheDir(CacheThumbs, &ok);
     int max = prod->get_length();
     while (!m_requestedThumbs.isEmpty()) {
         m_thumbMutex.lock();
         int pos = m_requestedThumbs.takeFirst();
         m_thumbMutex.unlock();
         if (ok && thumbFolder.exists(hash() + QLatin1Char('#') + QString::number(pos) + QStringLiteral(".png"))) {
             emit thumbReady(pos, QImage(thumbFolder.absoluteFilePath(hash() + QLatin1Char('#') + QString::number(pos) + QStringLiteral(".png"))));
             continue;
         }
         if (pos >= max) {
             pos = max - 1;
         }
         const QString path = url() + QLatin1Char('_') + QString::number(pos);
         QImage img;
         if (ThumbnailCache::get()->hasThumbnail(clipId(), pos, true)) {
             img = ThumbnailCache::get()->getThumbnail(clipId(), pos, true);
         }
         if (!img.isNull()) {
             emit thumbReady(pos, img);
             continue;
         }
         prod->seek(pos);
         Mlt::Frame *frame = prod->get_frame();
         frame->set("deinterlace_method", "onefield");
         frame->set("top_field_first", -1);
         if (frame->is_valid()) {
             img = KThumb::getFrame(frame, frameWidth, 150, !qFuzzyCompare(prod->profile()->sar(), 1));
             ThumbnailCache::get()->storeThumbnail(clipId(), pos, img, false);
             emit thumbReady(pos, img);
         }
         delete frame;
     }
 }
 
 int ProjectClip::audioChannels() const
 {
     if (!audioInfo()) {
         return 0;
     }
     return audioInfo()->channels();
 }
 
 void ProjectClip::discardAudioThumb()
 {
     QString audioThumbPath = getAudioThumbPath();
     if (!audioThumbPath.isEmpty()) {
         QFile::remove(audioThumbPath);
     }
     audioFrameCache.clear();
     qCDebug(KDENLIVE_LOG) << "////////////////////  DISCARD AUIIO THUMBNS";
     m_audioThumbCreated = false;
     pCore->jobManager()->discardJobs(clipId(), AbstractClipJob::AUDIOTHUMBJOB);
 }
 
 const QString ProjectClip::getAudioThumbPath()
 {
     if (audioInfo() == nullptr) {
         return QString();
     }
     int audioStream = audioInfo()->ffmpeg_audio_index();
     QString clipHash = hash();
     if (clipHash.isEmpty()) {
         return QString();
     }
     bool ok = false;
     QDir thumbFolder = pCore->currentDoc()->getCacheDir(CacheAudio, &ok);
     if (!ok) {
         return QString();
     }
     QString audioPath = thumbFolder.absoluteFilePath(clipHash);
     if (audioStream > 0) {
         audioPath.append(QLatin1Char('_') + QString::number(audioInfo()->audio_index()));
     }
     int roundedFps = (int)pCore->getCurrentFps();
     audioPath.append(QStringLiteral("_%1_audio.png").arg(roundedFps));
     return audioPath;
 }
 
 QStringList ProjectClip::updatedAnalysisData(const QString &name, const QString &data, int offset)
 {
     if (data.isEmpty()) {
         // Remove data
         return QStringList() << QString("kdenlive:clipanalysis." + name) << QString();
         // m_controller->resetProperty("kdenlive:clipanalysis." + name);
     }
     QString current = getProducerProperty("kdenlive:clipanalysis." + name);
     if (!current.isEmpty()) {
         if (KMessageBox::questionYesNo(QApplication::activeWindow(), i18n("Clip already contains analysis data %1", name), QString(), KGuiItem(i18n("Merge")),
                                        KGuiItem(i18n("Add"))) == KMessageBox::Yes) {
             // Merge data
             auto &profile = pCore->getCurrentProfile();
             Mlt::Geometry geometry(current.toUtf8().data(), duration().frames(profile->fps()), profile->width(), profile->height());
             Mlt::Geometry newGeometry(data.toUtf8().data(), duration().frames(profile->fps()), profile->width(), profile->height());
             Mlt::GeometryItem item;
             int pos = 0;
             while (newGeometry.next_key(&item, pos) == 0) {
                 pos = item.frame();
                 item.frame(pos + offset);
                 pos++;
                 geometry.insert(item);
             }
             return QStringList() << QString("kdenlive:clipanalysis." + name) << geometry.serialise();
             // m_controller->setProperty("kdenlive:clipanalysis." + name, geometry.serialise());
         }
         // Add data with another name
         int i = 1;
         QString previous = getProducerProperty("kdenlive:clipanalysis." + name + QString::number(i));
         while (!previous.isEmpty()) {
             ++i;
             previous = getProducerProperty("kdenlive:clipanalysis." + name + QString::number(i));
         }
         return QStringList() << QString("kdenlive:clipanalysis." + name + QString::number(i)) << geometryWithOffset(data, offset);
         // m_controller->setProperty("kdenlive:clipanalysis." + name + QLatin1Char(' ') + QString::number(i), geometryWithOffset(data, offset));
     }
     return QStringList() << QString("kdenlive:clipanalysis." + name) << geometryWithOffset(data, offset);
     // m_controller->setProperty("kdenlive:clipanalysis." + name, geometryWithOffset(data, offset));
 }
 
 QMap<QString, QString> ProjectClip::analysisData(bool withPrefix)
 {
     return getPropertiesFromPrefix(QStringLiteral("kdenlive:clipanalysis."), withPrefix);
 }
 
 const QString ProjectClip::geometryWithOffset(const QString &data, int offset)
 {
     if (offset == 0) {
         return data;
     }
     auto &profile = pCore->getCurrentProfile();
     Mlt::Geometry geometry(data.toUtf8().data(), duration().frames(profile->fps()), profile->width(), profile->height());
     Mlt::Geometry newgeometry(nullptr, duration().frames(profile->fps()), profile->width(), profile->height());
     Mlt::GeometryItem item;
     int pos = 0;
     while (geometry.next_key(&item, pos) == 0) {
         pos = item.frame();
         item.frame(pos + offset);
         pos++;
         newgeometry.insert(item);
     }
     return newgeometry.serialise();
 }
 
 bool ProjectClip::isSplittable() const
 {
     return (m_clipType == ClipType::AV || m_clipType == ClipType::Playlist);
 }
 
 void ProjectClip::setBinEffectsEnabled(bool enabled)
 {
     ClipController::setBinEffectsEnabled(enabled);
 }
 
 void ProjectClip::registerService(std::weak_ptr<TimelineModel> timeline, int clipId, std::shared_ptr<Mlt::Producer> service, bool forceRegister)
 {
     if (!service->is_cut() || forceRegister) {
         int hasAudio = service->get_int("set.test_audio") == 0;
         int hasVideo = service->get_int("set.test_image") == 0;
         if (hasVideo && m_videoProducers.count(clipId) == 0) {
             // This is an undo producer, register it!
             m_videoProducers[clipId] = service;
             m_effectStack->addService(m_videoProducers[clipId]);
         } else if (hasAudio && m_audioProducers.count(clipId) == 0) {
             // This is an undo producer, register it!
             m_audioProducers[clipId] = service;
             m_effectStack->addService(m_audioProducers[clipId]);
         }
     }
     registerTimelineClip(timeline, clipId);
 }
 
 void ProjectClip::registerTimelineClip(std::weak_ptr<TimelineModel> timeline, int clipId)
 {
     Q_ASSERT(m_registeredClips.count(clipId) == 0);
     Q_ASSERT(!timeline.expired());
     m_registeredClips[clipId] = std::move(timeline);
     setRefCount((uint)m_registeredClips.size());
 }
 
 void ProjectClip::deregisterTimelineClip(int clipId)
 {
     qDebug() << " ** * DEREGISTERING TIMELINE CLIP: " << clipId;
     Q_ASSERT(m_registeredClips.count(clipId) > 0);
     m_registeredClips.erase(clipId);
     if (m_videoProducers.count(clipId) > 0) {
         m_effectStack->removeService(m_videoProducers[clipId]);
         m_videoProducers.erase(clipId);
     }
     if (m_audioProducers.count(clipId) > 0) {
         m_effectStack->removeService(m_audioProducers[clipId]);
         m_audioProducers.erase(clipId);
     }
     setRefCount((uint)m_registeredClips.size());
 }
 
 QList<int> ProjectClip::timelineInstances() const
 {
     QList<int> ids;
     for (std::map<int, std::weak_ptr<TimelineModel>>::const_iterator it = m_registeredClips.begin(); it != m_registeredClips.end(); ++it) {
         ids.push_back(it->first);
     }
     return ids;
 }
 
 bool ProjectClip::selfSoftDelete(Fun &undo, Fun &redo)
 {
     auto toDelete = m_registeredClips; // we cannot use m_registeredClips directly, because it will be modified during loop
     for (const auto &clip : toDelete) {
         if (m_registeredClips.count(clip.first) == 0) {
             // clip already deleted, was probably grouped with another one
             continue;
         }
         if (auto timeline = clip.second.lock()) {
             timeline->requestItemDeletion(clip.first, undo, redo);
         } else {
             qDebug() << "Error while deleting clip: timeline unavailable";
             Q_ASSERT(false);
             return false;
         }
     }
     return AbstractProjectItem::selfSoftDelete(undo, redo);
 }
 
 bool ProjectClip::isIncludedInTimeline()
 {
     return m_registeredClips.size() > 0;
 }
 
 void ProjectClip::updateChildProducers()
 {
     // TODO refac: the effect should be managed by an effectstack on the master
     /*
     // pass effect stack on all child producers
     QMutexLocker locker(&m_producerMutex);
     for (const auto &clip : m_timelineProducers) {
         if (auto producer = clip.second) {
             Clip clp(producer->parent());
             clp.deleteEffects();
             clp.replaceEffects(*m_masterProducer);
         }
     }
     */
 }
 
 void ProjectClip::replaceInTimeline()
 {
     for (const auto &clip : m_registeredClips) {
         if (auto timeline = clip.second.lock()) {
             timeline->requestClipReload(clip.first);
         } else {
             qDebug() << "Error while reloading clip: timeline unavailable";
             Q_ASSERT(false);
         }
     }
 }
 
 void ProjectClip::updateTimelineClips(QVector<int> roles)
 {
     for (const auto &clip : m_registeredClips) {
         if (auto timeline = clip.second.lock()) {
             timeline->requestClipUpdate(clip.first, roles);
         } else {
             qDebug() << "Error while reloading clip thumb: timeline unavailable";
             Q_ASSERT(false);
             return;
         }
     }
 }
diff --git a/tests/modeltest.cpp b/tests/modeltest.cpp
index 81470530c..b4f612770 100644
--- a/tests/modeltest.cpp
+++ b/tests/modeltest.cpp
@@ -1,2142 +1,2142 @@
 #include "logger.hpp"
 #include "test_utils.hpp"
 
 using namespace fakeit;
 std::default_random_engine g(42);
 Mlt::Profile profile_model;
 
 TEST_CASE("Basic creation/deletion of a track", "[TrackModel]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
     TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     Fake(Method(timMock, adjustAssetRange));
 
     // This is faked to allow to count calls
     Fake(Method(timMock, _resetView));
 
     int id1 = TrackModel::construct(timeline);
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 1);
     REQUIRE(timeline->getTrackPosition(id1) == 0);
     // In the current implementation, when a track is added/removed, the model is notified with _resetView
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     int id2 = TrackModel::construct(timeline);
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 2);
     REQUIRE(timeline->getTrackPosition(id2) == 1);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     int id3 = TrackModel::construct(timeline);
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 3);
     REQUIRE(timeline->getTrackPosition(id3) == 2);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     int id4;
     REQUIRE(timeline->requestTrackInsertion(1, id4));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 4);
     REQUIRE(timeline->getTrackPosition(id1) == 0);
     REQUIRE(timeline->getTrackPosition(id4) == 1);
     REQUIRE(timeline->getTrackPosition(id2) == 2);
     REQUIRE(timeline->getTrackPosition(id3) == 3);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     // Test deletion
     REQUIRE(timeline->requestTrackDeletion(id3));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 3);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     REQUIRE(timeline->requestTrackDeletion(id1));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 2);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     REQUIRE(timeline->requestTrackDeletion(id4));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 1);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     REQUIRE(timeline->requestTrackDeletion(id2));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getTracksCount() == 0);
     Verify(Method(timMock, _resetView)).Exactly(Once);
     RESET(timMock);
 
     SECTION("Delete a track with groups")
     {
         int tid1, tid2;
         REQUIRE(timeline->requestTrackInsertion(-1, tid1));
         REQUIRE(timeline->requestTrackInsertion(-1, tid2));
         REQUIRE(timeline->checkConsistency());
 
         QString binId = createProducer(profile_model, "red", binModel);
         int length = 20;
         int cid1, cid2, cid3, cid4;
         REQUIRE(timeline->requestClipInsertion(binId, tid1, 2, cid1));
         REQUIRE(timeline->requestClipInsertion(binId, tid2, 0, cid2));
         REQUIRE(timeline->requestClipInsertion(binId, tid2, length, cid3));
         REQUIRE(timeline->requestClipInsertion(binId, tid2, 2 * length, cid4));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipsCount() == 4);
         REQUIRE(timeline->getTracksCount() == 2);
 
         auto g1 = std::unordered_set<int>({cid1, cid3});
         auto g2 = std::unordered_set<int>({cid2, cid4});
         auto g3 = std::unordered_set<int>({cid1, cid4});
         REQUIRE(timeline->requestClipsGroup(g1));
         REQUIRE(timeline->requestClipsGroup(g2));
         REQUIRE(timeline->requestClipsGroup(g3));
         REQUIRE(timeline->checkConsistency());
 
         REQUIRE(timeline->requestTrackDeletion(tid1));
         REQUIRE(timeline->getClipsCount() == 3);
         REQUIRE(timeline->getTracksCount() == 1);
         REQUIRE(timeline->checkConsistency());
     }
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Basic creation/deletion of a clip", "[ClipModel]")
 {
     Logger::clear();
 
     auto binModel = pCore->projectItemModel();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
-    std::shared_ptr<TimelineItemModel> timeline = TimelineItemModel::construct(new Mlt::Profile(), guideModel, undoStack);
+    std::shared_ptr<TimelineItemModel> timeline = TimelineItemModel::construct(&profile_model, guideModel, undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     QString binId = createProducer(profile_model, "red", binModel);
     QString binId2 = createProducer(profile_model, "green", binModel);
 
     REQUIRE(timeline->getClipsCount() == 0);
     int id1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     REQUIRE(timeline->getClipsCount() == 1);
     REQUIRE(timeline->checkConsistency());
 
     int id2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
     REQUIRE(timeline->getClipsCount() == 2);
     REQUIRE(timeline->checkConsistency());
 
     int id3 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     REQUIRE(timeline->getClipsCount() == 3);
     REQUIRE(timeline->checkConsistency());
 
     // Test deletion
     REQUIRE(timeline->requestItemDeletion(id2));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getClipsCount() == 2);
     REQUIRE(timeline->requestItemDeletion(id3));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getClipsCount() == 1);
     REQUIRE(timeline->requestItemDeletion(id1));
     REQUIRE(timeline->checkConsistency());
     REQUIRE(timeline->getClipsCount() == 0);
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Clip manipulation", "[ClipModel]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     binModel->clean();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
-    TimelineItemModel tim(new Mlt::Profile(), undoStack);
+    TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     Fake(Method(timMock, adjustAssetRange));
 
     // This is faked to allow to count calls
     Fake(Method(timMock, _resetView));
     Fake(Method(timMock, _beginInsertRows));
     Fake(Method(timMock, _beginRemoveRows));
     Fake(Method(timMock, _endInsertRows));
     Fake(Method(timMock, _endRemoveRows));
 
     QString binId = createProducer(profile_model, "red", binModel);
     QString binId2 = createProducer(profile_model, "blue", binModel);
     QString binId3 = createProducer(profile_model, "green", binModel);
 
     int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int tid1 = TrackModel::construct(timeline);
     int tid2 = TrackModel::construct(timeline);
     int tid3 = TrackModel::construct(timeline);
     int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
     int cid3 = ClipModel::construct(timeline, binId3, -1, PlaylistState::VideoOnly);
     int cid4 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
 
     Verify(Method(timMock, _resetView)).Exactly(3_Times);
     RESET(timMock);
 
     // for testing purposes, we make sure the clip will behave as regular clips
     // (ie their size is fixed, we cannot resize them past their original size)
     timeline->m_allClips[cid1]->m_endlessResize = false;
     timeline->m_allClips[cid2]->m_endlessResize = false;
     timeline->m_allClips[cid3]->m_endlessResize = false;
     timeline->m_allClips[cid4]->m_endlessResize = false;
 
     SECTION("Insert a clip in a track and change track")
     {
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
         REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
 
         REQUIRE(timeline->getClipTrackId(cid1) == -1);
         REQUIRE(timeline->getClipPosition(cid1) == -1);
 
         int pos = 10;
         REQUIRE(timeline->requestClipMove(cid1, tid1, pos));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == pos);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
         // Check that the model was correctly notified
         CHECK_INSERT(Once);
 
         pos = 1;
         REQUIRE(timeline->requestClipMove(cid1, tid2, pos));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid2);
         REQUIRE(timeline->getClipPosition(cid1) == pos);
         REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
         CHECK_MOVE(Once);
 
         // Check conflicts
         int pos2 = binModel->getClipByBinID(binId)->frameDuration();
         REQUIRE(timeline->requestClipMove(cid2, tid1, pos2));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == pos2);
         REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         CHECK_INSERT(Once);
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, pos2 + 2));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid2);
         REQUIRE(timeline->getClipPosition(cid1) == pos);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == pos2);
         CHECK_MOVE(Once);
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, pos2 - 2));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid2);
         REQUIRE(timeline->getClipPosition(cid1) == pos);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == pos2);
         CHECK_MOVE(Once);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == pos2);
         CHECK_MOVE(Once);
     }
 
     int length = binModel->getClipByBinID(binId)->frameDuration();
     SECTION("Insert consecutive clips")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         CHECK_INSERT(Once);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, length));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == length);
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         CHECK_INSERT(Once);
     }
 
     SECTION("Resize orphan clip")
     {
         REQUIRE(timeline->getClipPlaytime(cid2) == length);
         REQUIRE(timeline->requestItemResize(cid2, 5, true) == 5);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(binModel->getClipByBinID(binId)->frameDuration() == length);
         auto inOut = std::pair<int, int>{0, 4};
         REQUIRE(timeline->m_allClips[cid2]->getInOut() == inOut);
         REQUIRE(timeline->getClipPlaytime(cid2) == 5);
         REQUIRE(timeline->requestItemResize(cid2, 10, false) == -1);
         REQUIRE(timeline->requestItemResize(cid2, length + 1, true) == -1);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipPlaytime(cid2) == 5);
         REQUIRE(timeline->getClipPlaytime(cid2) == 5);
         REQUIRE(timeline->requestItemResize(cid2, 2, false) == 2);
         REQUIRE(timeline->checkConsistency());
         inOut = std::pair<int, int>{3, 4};
         REQUIRE(timeline->m_allClips[cid2]->getInOut() == inOut);
         REQUIRE(timeline->getClipPlaytime(cid2) == 2);
         REQUIRE(timeline->requestItemResize(cid2, length, true) == -1);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipPlaytime(cid2) == 2);
         CAPTURE(timeline->m_allClips[cid2]->m_producer->get_in());
         REQUIRE(timeline->requestItemResize(cid2, length - 2, true) == -1);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->requestItemResize(cid2, length - 3, true) == length - 3);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 3);
     }
 
     SECTION("Resize inserted clips")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         CHECK_INSERT(Once);
 
         REQUIRE(timeline->requestItemResize(cid1, 5, true) == 5);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipPlaytime(cid1) == 5);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         CHECK_RESIZE(Once);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(binModel->getClipByBinID(binId)->frameDuration() == length);
         CHECK_INSERT(Once);
 
         REQUIRE(timeline->requestItemResize(cid1, 6, true) == -1);
         REQUIRE(timeline->requestItemResize(cid1, 6, false) == -1);
         REQUIRE(timeline->checkConsistency());
         NO_OTHERS();
 
         REQUIRE(timeline->requestItemResize(cid2, length - 5, false) == length - 5);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipPosition(cid2) == 10);
         CHECK_RESIZE(Once);
 
         REQUIRE(timeline->requestItemResize(cid1, 10, true) == 10);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         CHECK_RESIZE(Once);
     }
 
     SECTION("Change track of resized clips")
     {
         // // REQUIRE(timeline->allowClipMove(cid2, tid1, 5));
         REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
 
         // // REQUIRE(timeline->allowClipMove(cid1, tid2, 10));
         REQUIRE(timeline->requestClipMove(cid1, tid2, 10));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
 
         REQUIRE(timeline->requestItemResize(cid1, 5, false) == 5);
         REQUIRE(timeline->checkConsistency());
 
         // // REQUIRE(timeline->allowClipMove(cid1, tid1, 0));
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
     }
 
     SECTION("Clip Move")
     {
         REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid2) == 5);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5 + length));
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5 + length);
             REQUIRE(timeline->getClipPosition(cid2) == 5);
         };
         state();
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 3 + length));
         state();
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
         state();
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 0));
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5 + length);
             REQUIRE(timeline->getClipPosition(cid2) == 0);
         };
         state2();
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
         state2();
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, length - 5));
         state2();
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, length));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length);
         REQUIRE(timeline->getClipPosition(cid2) == 0);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length);
         REQUIRE(timeline->getClipPosition(cid2) == 0);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, length - 5));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length - 5);
         REQUIRE(timeline->getClipPosition(cid2) == 0);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length - 5);
         REQUIRE(timeline->getClipPosition(cid2) == 5);
 
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length - 5);
         REQUIRE(timeline->getClipPosition(cid2) == 5);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == length - 5);
         REQUIRE(timeline->getClipPosition(cid2) == 0);
     }
 
     SECTION("Move and resize")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->requestItemResize(cid1, length - 2, false) == length - 2);
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPlaytime(cid1) == length - 2);
         };
         state();
 
         // try to resize past the left end
         REQUIRE(timeline->requestItemResize(cid1, length, false) == -1);
         state();
 
         REQUIRE(timeline->requestItemResize(cid1, length - 4, true) == length - 4);
         REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4 + 1));
         REQUIRE(timeline->requestItemResize(cid2, length - 2, false) == length - 2);
         REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4 + 1));
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPlaytime(cid1) == length - 4);
             REQUIRE(timeline->getClipPosition(cid2) == length - 4 + 1);
             REQUIRE(timeline->getClipPlaytime(cid2) == length - 2);
         };
         state2();
 
         // the gap between the two clips is 1 frame, we try to resize them by 2 frames
         REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == -1);
         state2();
         REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
         state2();
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, length - 4));
         auto state3 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPlaytime(cid1) == length - 4);
             REQUIRE(timeline->getClipPosition(cid2) == length - 4);
             REQUIRE(timeline->getClipPlaytime(cid2) == length - 2);
         };
         state3();
 
         // Now the gap is 0 frames, the resize should still fail
         REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == -1);
         state3();
         REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
         state3();
 
         // We move cid1 out of the way
         REQUIRE(timeline->requestClipMove(cid1, tid2, 0));
         // now resize should work
         REQUIRE(timeline->requestItemResize(cid1, length - 2, true) == length - 2);
         REQUIRE(timeline->requestItemResize(cid2, length, false) == length);
         REQUIRE(timeline->checkConsistency());
     }
 
     SECTION("Group move")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->requestClipMove(cid2, tid1, length + 3));
         REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 5));
         REQUIRE(timeline->requestClipMove(cid4, tid2, 4));
 
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipTrackId(cid2) == tid1);
         REQUIRE(timeline->getClipTrackId(cid3) == tid1);
         REQUIRE(timeline->getClipTrackId(cid4) == tid2);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         REQUIRE(timeline->getClipPosition(cid2) == length + 3);
         REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5);
         REQUIRE(timeline->getClipPosition(cid4) == 4);
 
         // check that move is possible without groups
         REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 3));
         REQUIRE(timeline->checkConsistency());
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
         // check that move is possible without groups
         REQUIRE(timeline->requestClipMove(cid4, tid2, 9));
         REQUIRE(timeline->checkConsistency());
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
 
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipTrackId(cid4) == tid2);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPosition(cid2) == length + 3);
             REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5);
             REQUIRE(timeline->getClipPosition(cid4) == 4);
         };
         state();
 
         // grouping
         REQUIRE(timeline->requestClipsGroup({cid1, cid3}));
         REQUIRE(timeline->requestClipsGroup({cid1, cid4}));
 
         // move left is now forbidden, because clip1 is at position 0
         REQUIRE_FALSE(timeline->requestClipMove(cid3, tid1, 2 * length + 3));
         state();
 
         // this move is impossible, because clip1 runs into clip2
         REQUIRE_FALSE(timeline->requestClipMove(cid4, tid2, 9));
         state();
 
         // this move is possible
         REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * length + 8));
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
             REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid3) == 0);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipTrackId(cid4) == tid2);
             REQUIRE(timeline->getClipPosition(cid1) == 3);
             REQUIRE(timeline->getClipPosition(cid2) == length + 3);
             REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 8);
             REQUIRE(timeline->getClipPosition(cid4) == 7);
         };
         state1();
 
         // this move is possible
         REQUIRE(timeline->requestClipMove(cid1, tid2, 8));
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid2) == 2);
             REQUIRE(timeline->getTrackClipsCount(tid3) == 1);
             REQUIRE(timeline->getClipTrackId(cid1) == tid2);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid2);
             REQUIRE(timeline->getClipTrackId(cid4) == tid3);
             REQUIRE(timeline->getClipPosition(cid1) == 8);
             REQUIRE(timeline->getClipPosition(cid2) == length + 3);
             REQUIRE(timeline->getClipPosition(cid3) == 2 * length + 5 + 8);
             REQUIRE(timeline->getClipPosition(cid4) == 4 + 8);
         };
         state2();
 
         undoStack->undo();
         state1();
 
         undoStack->redo();
         state2();
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 3));
         state1();
     }
 
     SECTION("Group move consecutive clips")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 7));
         REQUIRE(timeline->requestClipMove(cid2, tid1, 7 + length));
         REQUIRE(timeline->requestClipMove(cid3, tid1, 7 + 2 * length));
         REQUIRE(timeline->requestClipMove(cid4, tid1, 7 + 3 * length));
         REQUIRE(timeline->requestClipsGroup({cid1, cid2, cid3, cid4}));
 
         auto state = [&](int tid, int start) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid) == 4);
             int i = 0;
             for (int cid : std::vector<int>({cid1, cid2, cid3, cid4})) {
                 REQUIRE(timeline->getClipTrackId(cid) == tid);
                 REQUIRE(timeline->getClipPosition(cid) == start + i * length);
                 REQUIRE(timeline->getClipPlaytime(cid) == length);
                 i++;
             }
         };
         state(tid1, 7);
 
         auto check_undo = [&](int target, int tid, int oldTid) {
             state(tid, target);
             undoStack->undo();
             state(oldTid, 7);
             undoStack->redo();
             state(tid, target);
             undoStack->undo();
             state(oldTid, 7);
         };
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 6));
         qDebug() << "state1";
         state(tid1, 6);
         undoStack->undo();
         state(tid1, 7);
         undoStack->redo();
         state(tid1, 6);
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         qDebug() << "state2";
         state(tid1, 0);
         undoStack->undo();
         state(tid1, 6);
         undoStack->redo();
         state(tid1, 0);
         undoStack->undo();
         state(tid1, 6);
         undoStack->undo();
         state(tid1, 7);
 
         REQUIRE(timeline->requestClipMove(cid3, tid1, 1 + 2 * length));
         qDebug() << "state3";
         check_undo(1, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid4, tid1, 4 + 3 * length));
         qDebug() << "state4";
         check_undo(4, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid4, tid1, 11 + 3 * length));
         qDebug() << "state5";
         check_undo(11, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 13 + length));
         qDebug() << "state6";
         check_undo(13, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 20));
         qDebug() << "state7";
         check_undo(20, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid4, tid1, 7 + 4 * length));
         qDebug() << "state8";
         check_undo(length + 7, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 7 + 2 * length));
         qDebug() << "state9";
         check_undo(length + 7, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 7 + length));
         qDebug() << "state10";
         check_undo(length + 7, tid1, tid1);
 
         REQUIRE(timeline->requestClipMove(cid2, tid2, 8 + length));
         qDebug() << "state11";
         check_undo(8, tid2, tid1);
     }
 
     SECTION("Group move to unavailable track")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 10));
         REQUIRE(timeline->requestClipMove(cid2, tid2, 12));
         REQUIRE(timeline->requestClipsGroup({cid1, cid2}));
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid2) == 1);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid2);
             REQUIRE(timeline->getClipPosition(cid1) == 10);
             REQUIRE(timeline->getClipPosition(cid2) == 12);
         };
         state();
 
         REQUIRE_FALSE(timeline->requestClipMove(cid2, tid1, 10));
         state();
         REQUIRE_FALSE(timeline->requestClipMove(cid2, tid1, 100));
         state();
         REQUIRE_FALSE(timeline->requestClipMove(cid1, tid3, 100));
         state();
     }
 
     SECTION("Group move with non-consecutive track ids")
     {
         int tid5 = TrackModel::construct(timeline);
         int cid6 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
         Q_UNUSED(cid6);
         int tid6 = TrackModel::construct(timeline);
         REQUIRE(tid5 + 1 != tid6);
 
         REQUIRE(timeline->requestClipMove(cid1, tid5, 10));
         REQUIRE(timeline->requestClipMove(cid2, tid5, length + 10));
         REQUIRE(timeline->requestClipsGroup({cid1, cid2}));
         auto state = [&](int t) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(t) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == t);
             REQUIRE(timeline->getClipTrackId(cid2) == t);
             REQUIRE(timeline->getClipPosition(cid1) == 10);
             REQUIRE(timeline->getClipPosition(cid2) == 10 + length);
         };
         state(tid5);
         REQUIRE(timeline->requestClipMove(cid1, tid6, 10));
         state(tid6);
     }
 
     SECTION("Movement of AV groups")
     {
         int tid6b = TrackModel::construct(timeline, -1, -1, QString(), true);
         int tid6 = TrackModel::construct(timeline, -1, -1, QString(), true);
         int tid5 = TrackModel::construct(timeline);
         int tid5b = TrackModel::construct(timeline);
 
         QString binId3 = createProducerWithSound(profile_model, binModel);
 
         int cid6 = -1;
         REQUIRE(timeline->requestClipInsertion(binId3, tid5, 3, cid6, true, true, false));
         int cid7 = timeline->m_groups->getSplitPartner(cid6);
 
         auto state = [&](int pos) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid5) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid6) == 1);
             REQUIRE(timeline->getClipTrackId(cid6) == tid5);
             REQUIRE(timeline->getClipTrackId(cid7) == tid6);
             REQUIRE(timeline->getClipPosition(cid6) == pos);
             REQUIRE(timeline->getClipPosition(cid7) == pos);
             REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::VideoOnly);
             REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::AudioOnly);
         };
         state(3);
 
         // simple translation on the right
         REQUIRE(timeline->requestClipMove(cid6, tid5, 10, true, true, true));
 
         state(10);
         undoStack->undo();
         state(3);
         undoStack->redo();
         state(10);
 
         // simple translation on the left, moving the audio clip this time
         REQUIRE(timeline->requestClipMove(cid7, tid6, 1, true, true, true));
         state(1);
         undoStack->undo();
         state(10);
         undoStack->redo();
         state(1);
 
         // change track, moving video
         REQUIRE(timeline->requestClipMove(cid6, tid5b, 7, true, true, true));
         auto state2 = [&](int pos) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid5b) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid6b) == 1);
             REQUIRE(timeline->getClipTrackId(cid6) == tid5b);
             REQUIRE(timeline->getClipTrackId(cid7) == tid6b);
             REQUIRE(timeline->getClipPosition(cid6) == pos);
             REQUIRE(timeline->getClipPosition(cid7) == pos);
             REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::VideoOnly);
             REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::AudioOnly);
         };
         state2(7);
         undoStack->undo();
         state(1);
         undoStack->redo();
         state2(7);
 
         // change track, moving audio
         REQUIRE(timeline->requestClipMove(cid7, tid6b, 2, true, true, true));
         state2(2);
         undoStack->undo();
         state2(7);
         undoStack->redo();
         state2(2);
 
         undoStack->undo();
         undoStack->undo();
         state(1);
 
         // Switching audio and video, going to the extra track
         REQUIRE(timeline->requestClipMove(cid7, tid5b, 2, true, true, true) == 0);
         // This test is invalid. AV clips cannot be switched between audio and video clips anymore
         /*auto state3 = [&](int pos) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid5b) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid6b) == 1);
             REQUIRE(timeline->getClipTrackId(cid6) == tid6b);
             REQUIRE(timeline->getClipTrackId(cid7) == tid5b);
             REQUIRE(timeline->getClipPosition(cid6) == pos);
             REQUIRE(timeline->getClipPosition(cid7) == pos);
             REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::VideoOnly);
             REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::AudioOnly);
         };
         state3(2);
         undoStack->undo();
         state(1);
         undoStack->redo();
         state3(2);
         undoStack->undo();
         state(1);*/
 
         // Switching audio and video, switching tracks in place
         REQUIRE(timeline->requestClipMove(cid6, tid6, 1, true, true, true) == 0);
         /*auto state4 = [&](int pos) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid5) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid6) == 1);
             REQUIRE(timeline->getClipTrackId(cid6) == tid6);
             REQUIRE(timeline->getClipTrackId(cid7) == tid5);
             REQUIRE(timeline->getClipPosition(cid6) == pos);
             REQUIRE(timeline->getClipPosition(cid7) == pos);
             REQUIRE(timeline->getClipPtr(cid7)->clipState() == PlaylistState::VideoOnly);
             REQUIRE(timeline->getClipPtr(cid6)->clipState() == PlaylistState::AudioOnly);
         };
         state4(1);
         undoStack->undo();
         state(1);
         undoStack->redo();
         state4(1);*/
     }
 
     SECTION("Clip copy")
     {
         int cid6 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
         int l = timeline->getClipPlaytime(cid6);
         REQUIRE(timeline->requestItemResize(cid6, l - 3, true, true, -1) == l - 3);
         REQUIRE(timeline->requestItemResize(cid6, l - 7, false, true, -1) == l - 7);
 
         int newId;
 
         std::function<bool(void)> undo = []() { return true; };
         std::function<bool(void)> redo = []() { return true; };
         REQUIRE(TimelineFunctions::copyClip(timeline, cid6, newId, PlaylistState::VideoOnly, undo, redo));
         REQUIRE(timeline->m_allClips[cid6]->binId() == timeline->m_allClips[newId]->binId());
         // TODO check effects
     }
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Check id unicity", "[ClipModel]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     binModel->clean();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
-    TimelineItemModel tim(new Mlt::Profile(), undoStack);
+    TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     RESET(timMock);
 
     QString binId = createProducer(profile_model, "red", binModel);
 
     std::vector<int> track_ids;
     std::unordered_set<int> all_ids;
 
     std::bernoulli_distribution coin(0.5);
 
     const int nbr = 20;
 
     for (int i = 0; i < nbr; i++) {
         if (coin(g)) {
             int tid = TrackModel::construct(timeline);
             REQUIRE(all_ids.count(tid) == 0);
             all_ids.insert(tid);
             track_ids.push_back(tid);
             REQUIRE(timeline->getTracksCount() == track_ids.size());
         } else {
             int cid = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
             REQUIRE(all_ids.count(cid) == 0);
             all_ids.insert(cid);
             REQUIRE(timeline->getClipsCount() == all_ids.size() - track_ids.size());
         }
     }
 
     REQUIRE(timeline->checkConsistency());
     REQUIRE(all_ids.size() == nbr);
     REQUIRE(all_ids.size() != track_ids.size());
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Undo and Redo", "[ClipModel]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     binModel->clean();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
-    TimelineItemModel tim(new Mlt::Profile(), undoStack);
+    TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     RESET(timMock);
 
     QString binId = createProducer(profile_model, "red", binModel);
     QString binId2 = createProducer(profile_model, "blue", binModel);
 
     int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int tid1 = TrackModel::construct(timeline);
     int tid2 = TrackModel::construct(timeline);
     int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
 
     timeline->m_allClips[cid1]->m_endlessResize = false;
     timeline->m_allClips[cid2]->m_endlessResize = false;
 
     int length = 20;
     int nclips = timeline->m_allClips.size();
 
     SECTION("requestCreateClip")
     {
         // an invalid clip id shouldn't get created
         {
             int temp;
             Fun undo = []() { return true; };
             Fun redo = []() { return true; };
             REQUIRE_FALSE(timeline->requestClipCreation("impossible bin id", temp, PlaylistState::VideoOnly, 1., undo, redo));
         }
 
         auto state0 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips);
         };
         state0();
 
         QString binId3 = createProducer(profile_model, "green", binModel);
         int cid3;
         {
             Fun undo = []() { return true; };
             Fun redo = []() { return true; };
             REQUIRE(timeline->requestClipCreation(binId3, cid3, PlaylistState::VideoOnly, 1., undo, redo));
             pCore->pushUndo(undo, redo, QString());
         }
 
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips + 1);
             REQUIRE(timeline->getClipPlaytime(cid3) == length);
             REQUIRE(timeline->getClipTrackId(cid3) == -1);
         };
         state1();
 
         QString binId4 = binId3 + "/1/10";
         int cid4;
         {
             Fun undo = []() { return true; };
             Fun redo = []() { return true; };
             REQUIRE(timeline->requestClipCreation(binId4, cid4, PlaylistState::VideoOnly, 1., undo, redo));
             pCore->pushUndo(undo, redo, QString());
         }
 
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips + 2);
             REQUIRE(timeline->getClipPlaytime(cid4) == 10);
             REQUIRE(timeline->getClipTrackId(cid4) == -1);
             auto inOut = std::pair<int, int>({1, 10});
             REQUIRE(timeline->m_allClips.at(cid4)->getInOut() == inOut);
             REQUIRE(timeline->getClipPlaytime(cid3) == length);
             REQUIRE(timeline->getClipTrackId(cid3) == -1);
         };
         state2();
         undoStack->undo();
         state1();
         undoStack->undo();
         state0();
         undoStack->redo();
         state1();
         undoStack->redo();
         state2();
     }
 
     SECTION("requestInsertClip")
     {
         auto state0 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips);
         };
         state0();
 
         QString binId3 = createProducer(profile_model, "green", binModel);
         int cid3;
         REQUIRE(timeline->requestClipInsertion(binId3, tid1, 12, cid3, true));
 
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips + 1);
             REQUIRE(timeline->getClipPlaytime(cid3) == length);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipPosition(cid3) == 12);
         };
         state1();
 
         QString binId4 = binId3 + "/1/10";
         int cid4;
         REQUIRE(timeline->requestClipInsertion(binId4, tid2, 17, cid4, true));
 
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->m_allClips.size() == nclips + 2);
             REQUIRE(timeline->getClipPlaytime(cid4) == 10);
             REQUIRE(timeline->getClipTrackId(cid4) == tid2);
             REQUIRE(timeline->getClipPosition(cid4) == 17);
             auto inOut = std::pair<int, int>({1, 10});
             REQUIRE(timeline->m_allClips.at(cid4)->getInOut() == inOut);
             REQUIRE(timeline->getClipPlaytime(cid3) == length);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipPosition(cid3) == 12);
         };
         state2();
         undoStack->undo();
         state1();
         undoStack->undo();
         state0();
         undoStack->redo();
         state1();
         undoStack->redo();
         state2();
     }
     int init_index = undoStack->index();
 
     SECTION("Basic move undo")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 5);
         REQUIRE(undoStack->index() == init_index + 1);
         CHECK_INSERT(Once);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         REQUIRE(undoStack->index() == init_index + 2);
         // Move on same track does not trigger insert/remove row
         CHECK_MOVE(0);
 
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 5);
         REQUIRE(undoStack->index() == init_index + 1);
         CHECK_MOVE(0);
 
         undoStack->redo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 0);
         REQUIRE(undoStack->index() == init_index + 2);
         CHECK_MOVE(0);
 
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 5);
         REQUIRE(undoStack->index() == init_index + 1);
         CHECK_MOVE(0);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 2 * length));
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 2 * length);
         REQUIRE(undoStack->index() == init_index + 2);
         CHECK_MOVE(0);
 
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 5);
         REQUIRE(undoStack->index() == init_index + 1);
         CHECK_MOVE(0);
 
         undoStack->redo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
         REQUIRE(timeline->getClipTrackId(cid1) == tid1);
         REQUIRE(timeline->getClipPosition(cid1) == 2 * length);
         REQUIRE(undoStack->index() == init_index + 2);
         CHECK_MOVE(0);
 
         undoStack->undo();
         CHECK_MOVE(0);
         undoStack->undo();
         REQUIRE(timeline->checkConsistency());
         REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
         REQUIRE(timeline->getClipTrackId(cid1) == -1);
         REQUIRE(undoStack->index() == init_index);
         CHECK_REMOVE(Once);
     }
 
     SECTION("Basic resize orphan clip undo")
     {
         REQUIRE(timeline->getClipPlaytime(cid2) == length);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
         REQUIRE(undoStack->index() == init_index + 1);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
         REQUIRE(undoStack->index() == init_index + 2);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
 
         REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
         REQUIRE(undoStack->index() == init_index + 2);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
 
         undoStack->undo();
         REQUIRE(undoStack->index() == init_index + 1);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
 
         undoStack->redo();
         REQUIRE(undoStack->index() == init_index + 2);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 10);
 
         undoStack->undo();
         REQUIRE(undoStack->index() == init_index + 1);
         REQUIRE(timeline->getClipPlaytime(cid2) == length - 5);
 
         undoStack->undo();
         REQUIRE(undoStack->index() == init_index);
         REQUIRE(timeline->getClipPlaytime(cid2) == length);
     }
     SECTION("Basic resize inserted clip undo")
     {
         REQUIRE(timeline->getClipPlaytime(cid2) == length);
 
         auto check = [&](int pos, int l) {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getClipTrackId(cid2) == tid1);
             REQUIRE(timeline->getClipPlaytime(cid2) == l);
             REQUIRE(timeline->getClipPosition(cid2) == pos);
         };
         REQUIRE(timeline->requestClipMove(cid2, tid1, 5));
         INFO("Test 1");
         check(5, length);
         REQUIRE(undoStack->index() == init_index + 1);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 5, true) == length - 5);
         INFO("Test 2");
         check(5, length - 5);
         REQUIRE(undoStack->index() == init_index + 2);
 
         REQUIRE(timeline->requestItemResize(cid2, length - 10, false) == length - 10);
         INFO("Test 3");
         check(10, length - 10);
         REQUIRE(undoStack->index() == init_index + 3);
 
         REQUIRE(timeline->requestItemResize(cid2, length, false) == -1);
         INFO("Test 4");
         check(10, length - 10);
         REQUIRE(undoStack->index() == init_index + 3);
 
         undoStack->undo();
         INFO("Test 5");
         check(5, length - 5);
         REQUIRE(undoStack->index() == init_index + 2);
 
         undoStack->redo();
         INFO("Test 6");
         check(10, length - 10);
         REQUIRE(undoStack->index() == init_index + 3);
 
         undoStack->undo();
         INFO("Test 7");
         check(5, length - 5);
         REQUIRE(undoStack->index() == init_index + 2);
 
         undoStack->undo();
         INFO("Test 8");
         check(5, length);
         REQUIRE(undoStack->index() == init_index + 1);
     }
     SECTION("Clip Insertion Undo")
     {
         QString binId3 = createProducer(profile_model, "red", binModel);
 
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(undoStack->index() == init_index + 1);
         };
         state1();
 
         int cid3;
         REQUIRE_FALSE(timeline->requestClipInsertion(binId3, tid1, 5, cid3));
         state1();
 
         REQUIRE_FALSE(timeline->requestClipInsertion(binId3, tid1, 6, cid3));
         state1();
 
         REQUIRE(timeline->requestClipInsertion(binId3, tid1, 5 + length, cid3));
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(timeline->getClipPosition(cid3) == 5 + length);
             REQUIRE(timeline->m_allClips[cid3]->isValid());
             REQUIRE(undoStack->index() == init_index + 2);
         };
         state2();
 
         REQUIRE(timeline->requestClipMove(cid3, tid1, 10 + length));
         auto state3 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(timeline->getClipPosition(cid3) == 10 + length);
             REQUIRE(undoStack->index() == init_index + 3);
         };
         state3();
 
         REQUIRE(timeline->requestItemResize(cid3, 1, true) == 1);
         auto state4 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 2);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(cid3) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(timeline->getClipPlaytime(cid3) == 1);
             REQUIRE(timeline->getClipPosition(cid3) == 10 + length);
             REQUIRE(undoStack->index() == init_index + 4);
         };
         state4();
 
         undoStack->undo();
         state3();
 
         undoStack->undo();
         state2();
 
         undoStack->undo();
         state1();
 
         undoStack->redo();
         state2();
 
         undoStack->redo();
         state3();
 
         undoStack->redo();
         state4();
 
         undoStack->undo();
         state3();
 
         undoStack->undo();
         state2();
 
         undoStack->undo();
         state1();
     }
 
     SECTION("Clip Deletion undo")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(undoStack->index() == init_index + 1);
         };
         state1();
 
         int nbClips = timeline->getClipsCount();
         REQUIRE(timeline->requestItemDeletion(cid1));
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 0);
             REQUIRE(timeline->getClipsCount() == nbClips - 1);
             REQUIRE(undoStack->index() == init_index + 2);
         };
         state2();
 
         undoStack->undo();
         state1();
 
         undoStack->redo();
         state2();
 
         undoStack->undo();
         state1();
     }
 
     SECTION("Track insertion undo")
     {
         std::map<int, int> orig_trackPositions, final_trackPositions;
         for (const auto &it : timeline->m_iteratorTable) {
             int track = it.first;
             int pos = timeline->getTrackPosition(track);
             orig_trackPositions[track] = pos;
             if (pos >= 1) pos++;
             final_trackPositions[track] = pos;
         }
         auto checkPositions = [&](const std::map<int, int> &pos) {
             for (const auto &p : pos) {
                 REQUIRE(timeline->getTrackPosition(p.first) == p.second);
             }
         };
         checkPositions(orig_trackPositions);
         int new_tid;
         REQUIRE(timeline->requestTrackInsertion(1, new_tid));
         checkPositions(final_trackPositions);
 
         undoStack->undo();
         checkPositions(orig_trackPositions);
 
         undoStack->redo();
         checkPositions(final_trackPositions);
 
         undoStack->undo();
         checkPositions(orig_trackPositions);
     }
 
     SECTION("Track deletion undo")
     {
         int nb_clips = timeline->getClipsCount();
         int nb_tracks = timeline->getTracksCount();
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
         auto state1 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(undoStack->index() == init_index + 1);
             REQUIRE(timeline->getClipsCount() == nb_clips);
             REQUIRE(timeline->getTracksCount() == nb_tracks);
         };
         state1();
 
         REQUIRE(timeline->requestTrackDeletion(tid1));
         REQUIRE(timeline->getClipsCount() == nb_clips - 1);
         REQUIRE(timeline->getTracksCount() == nb_tracks - 1);
 
         undoStack->undo();
         state1();
 
         undoStack->redo();
         REQUIRE(timeline->getClipsCount() == nb_clips - 1);
         REQUIRE(timeline->getTracksCount() == nb_tracks - 1);
 
         undoStack->undo();
         state1();
     }
 
     int clipCount = timeline->m_allClips.size();
     SECTION("Clip creation and resize")
     {
         int cid6;
         auto state0 = [&]() {
             REQUIRE(timeline->m_allClips.size() == clipCount);
             REQUIRE(timeline->checkConsistency());
         };
         state0();
 
         {
             std::function<bool(void)> undo = []() { return true; };
             std::function<bool(void)> redo = []() { return true; };
             REQUIRE(timeline->requestClipCreation(binId, cid6, PlaylistState::VideoOnly, 1., undo, redo));
             pCore->pushUndo(undo, redo, QString());
         }
         int l = timeline->getClipPlaytime(cid6);
 
         auto state1 = [&]() {
             REQUIRE(timeline->m_allClips.size() == clipCount + 1);
             REQUIRE(timeline->isClip(cid6));
             REQUIRE(timeline->getClipTrackId(cid6) == -1);
             REQUIRE(timeline->getClipPlaytime(cid6) == l);
         };
         state1();
 
         {
             std::function<bool(void)> undo = []() { return true; };
             std::function<bool(void)> redo = []() { return true; };
             REQUIRE(timeline->requestItemResize(cid6, l - 5, true, true, undo, redo, false));
             pCore->pushUndo(undo, redo, QString());
         }
         auto state2 = [&]() {
             REQUIRE(timeline->m_allClips.size() == clipCount + 1);
             REQUIRE(timeline->isClip(cid6));
             REQUIRE(timeline->getClipTrackId(cid6) == -1);
             REQUIRE(timeline->getClipPlaytime(cid6) == l - 5);
         };
         state2();
 
         {
             std::function<bool(void)> undo = []() { return true; };
             std::function<bool(void)> redo = []() { return true; };
             REQUIRE(timeline->requestClipMove(cid6, tid1, 7, true, true, undo, redo));
             pCore->pushUndo(undo, redo, QString());
         }
         auto state3 = [&]() {
             REQUIRE(timeline->m_allClips.size() == clipCount + 1);
             REQUIRE(timeline->isClip(cid6));
             REQUIRE(timeline->getClipTrackId(cid6) == tid1);
             REQUIRE(timeline->getClipPosition(cid6) == 7);
             REQUIRE(timeline->getClipPlaytime(cid6) == l - 5);
         };
         state3();
 
         {
             std::function<bool(void)> undo = []() { return true; };
             std::function<bool(void)> redo = []() { return true; };
             REQUIRE(timeline->requestItemResize(cid6, l - 6, false, true, undo, redo, false));
             pCore->pushUndo(undo, redo, QString());
         }
         auto state4 = [&]() {
             REQUIRE(timeline->m_allClips.size() == clipCount + 1);
             REQUIRE(timeline->isClip(cid6));
             REQUIRE(timeline->getClipTrackId(cid6) == tid1);
             REQUIRE(timeline->getClipPosition(cid6) == 8);
             REQUIRE(timeline->getClipPlaytime(cid6) == l - 6);
         };
         state4();
 
         undoStack->undo();
         state3();
         undoStack->undo();
         state2();
         undoStack->undo();
         state1();
         undoStack->undo();
         state0();
         undoStack->redo();
         state1();
         undoStack->redo();
         state2();
         undoStack->redo();
         state3();
         undoStack->redo();
         state4();
     }
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Snapping", "[Snapping]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     binModel->clean();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
-    TimelineItemModel tim(new Mlt::Profile(), undoStack);
+    TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     RESET(timMock);
 
     QString binId = createProducer(profile_model, "red", binModel, 50);
     QString binId2 = createProducer(profile_model, "blue", binModel);
 
     int tid1 = TrackModel::construct(timeline);
     int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int tid2 = TrackModel::construct(timeline);
     int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
     int cid3 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
 
     timeline->m_allClips[cid1]->m_endlessResize = false;
     timeline->m_allClips[cid2]->m_endlessResize = false;
     timeline->m_allClips[cid3]->m_endlessResize = false;
 
     int length = timeline->getClipPlaytime(cid1);
     int length2 = timeline->getClipPlaytime(cid2);
     SECTION("getBlankSizeNearClip")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
 
         // before
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 0);
         // after
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == INT_MAX);
         REQUIRE(timeline->requestClipMove(cid1, tid1, 10));
         // before
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
         // after
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == INT_MAX);
         REQUIRE(timeline->requestClipMove(cid2, tid1, 25 + length));
         // before
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, false) == 15);
         // after
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == 15);
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, true) == INT_MAX);
 
         REQUIRE(timeline->requestClipMove(cid2, tid1, 10 + length));
         // before
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, false) == 10);
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, false) == 0);
         // after
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid1, true) == 0);
         REQUIRE(timeline->getTrackById(tid1)->getBlankSizeNearClip(cid2, true) == INT_MAX);
     }
     SECTION("Snap move to a single clip")
     {
         int beg = 30;
         // in the absence of other clips, a valid move shouldn't be modified
         for (int snap = -1; snap <= 5; ++snap) {
             REQUIRE(timeline->suggestClipMove(cid2, tid2, beg, -1, snap) == beg);
             REQUIRE(timeline->suggestClipMove(cid2, tid2, beg + length, -1, snap) == beg + length);
             REQUIRE(timeline->checkConsistency());
         }
 
         // We add a clip in first track to create snap points
         REQUIRE(timeline->requestClipMove(cid1, tid1, beg));
 
         // Now a clip in second track should snap to beginning
         auto check_snap = [&](int pos, int perturb, int snap) {
             if (snap >= perturb) {
                 REQUIRE(timeline->suggestClipMove(cid2, tid2, pos + perturb, -1, snap) == pos);
                 REQUIRE(timeline->suggestClipMove(cid2, tid2, pos - perturb, -1, snap) == pos);
             } else {
                 REQUIRE(timeline->suggestClipMove(cid2, tid2, pos + perturb, -1, snap) == pos + perturb);
                 REQUIRE(timeline->suggestClipMove(cid2, tid2, pos - perturb, -1, snap) == pos - perturb);
             }
         };
         for (int snap = -1; snap <= 5; ++snap) {
             for (int perturb = 0; perturb <= 6; ++perturb) {
                 // snap to beginning
                 check_snap(beg, perturb, snap);
                 check_snap(beg + length, perturb, snap);
                 // snap to end
                 check_snap(beg - length2, perturb, snap);
                 check_snap(beg + length - length2, perturb, snap);
                 REQUIRE(timeline->checkConsistency());
             }
         }
 
         // Same test, but now clip is moved in position 0 first
         REQUIRE(timeline->requestClipMove(cid2, tid2, 0));
         for (int snap = -1; snap <= 5; ++snap) {
             for (int perturb = 0; perturb <= 6; ++perturb) {
                 // snap to beginning
                 check_snap(beg, perturb, snap);
                 check_snap(beg + length, perturb, snap);
                 // snap to end
                 check_snap(beg - length2, perturb, snap);
                 check_snap(beg + length - length2, perturb, snap);
                 REQUIRE(timeline->checkConsistency());
             }
         }
     }
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }
 
 TEST_CASE("Advanced trimming operations", "[Trimming]")
 {
     Logger::clear();
     auto binModel = pCore->projectItemModel();
     binModel->clean();
     std::shared_ptr<DocUndoStack> undoStack = std::make_shared<DocUndoStack>(nullptr);
     std::shared_ptr<MarkerListModel> guideModel = std::make_shared<MarkerListModel>(undoStack);
 
     // Here we do some trickery to enable testing.
     // We mock the project class so that the undoStack function returns our undoStack
 
     Mock<ProjectManager> pmMock;
     When(Method(pmMock, undoStack)).AlwaysReturn(undoStack);
 
     ProjectManager &mocked = pmMock.get();
     pCore->m_projectManager = &mocked;
 
     // We also mock timeline object to spy few functions and mock others
-    TimelineItemModel tim(new Mlt::Profile(), undoStack);
+    TimelineItemModel tim(&profile_model, undoStack);
     Mock<TimelineItemModel> timMock(tim);
     auto timeline = std::shared_ptr<TimelineItemModel>(&timMock.get(), [](...) {});
     TimelineItemModel::finishConstruct(timeline, guideModel);
 
     RESET(timMock);
 
     QString binId = createProducer(profile_model, "red", binModel);
     QString binId2 = createProducer(profile_model, "blue", binModel);
     QString binId3 = createProducerWithSound(profile_model, binModel);
 
     int cid1 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int tid1 = TrackModel::construct(timeline);
     int tid2 = TrackModel::construct(timeline);
     int tid3 = TrackModel::construct(timeline);
     // Add an audio track
     int tid4 = TrackModel::construct(timeline, -1, -1, QString(), true);
     int cid2 = ClipModel::construct(timeline, binId2, -1, PlaylistState::VideoOnly);
     int cid3 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int cid4 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int cid5 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int cid6 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
     int cid7 = ClipModel::construct(timeline, binId, -1, PlaylistState::VideoOnly);
 
     int audio1 = ClipModel::construct(timeline, binId3, -1, PlaylistState::VideoOnly);
     int audio2 = ClipModel::construct(timeline, binId3, -1, PlaylistState::VideoOnly);
     int audio3 = ClipModel::construct(timeline, binId3, -1, PlaylistState::VideoOnly);
 
     timeline->m_allClips[cid1]->m_endlessResize = false;
     timeline->m_allClips[cid2]->m_endlessResize = false;
     timeline->m_allClips[cid3]->m_endlessResize = false;
     timeline->m_allClips[cid4]->m_endlessResize = false;
     timeline->m_allClips[cid5]->m_endlessResize = false;
     timeline->m_allClips[cid6]->m_endlessResize = false;
     timeline->m_allClips[cid7]->m_endlessResize = false;
 
     SECTION("Clip splitting")
     {
         // Trivial split
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         int l = timeline->getClipPlaytime(cid2);
         REQUIRE(timeline->requestItemResize(cid2, l - 3, true) == l - 3);
         REQUIRE(timeline->requestItemResize(cid2, l - 5, false) == l - 5);
         REQUIRE(timeline->requestClipMove(cid2, tid1, l));
         REQUIRE(timeline->requestClipMove(cid3, tid1, l + l - 5));
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(cid1) == l);
             REQUIRE(timeline->getClipPlaytime(cid2) == l - 5);
             REQUIRE(timeline->getClipPlaytime(cid3) == l);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPosition(cid2) == l);
             REQUIRE(timeline->getClipPosition(cid3) == l + l - 5);
             REQUIRE(timeline->getClipPtr(cid2)->getIn() == 2);
             REQUIRE(timeline->getClipPtr(cid2)->getOut() == l - 4);
         };
         state();
 
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, 0));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, 5 * l));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, l));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, l + l - 5));
         state();
 
         REQUIRE(TimelineFunctions::requestClipCut(timeline, cid2, l + 4));
         int splitted = timeline->getClipByPosition(tid1, l + 5);
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(cid1) == l);
             REQUIRE(timeline->getClipPlaytime(cid2) == 4);
             REQUIRE(timeline->getClipPlaytime(splitted) == l - 9);
             REQUIRE(timeline->getClipPlaytime(cid3) == l);
             REQUIRE(timeline->getClipPosition(cid1) == 0);
             REQUIRE(timeline->getClipPosition(cid2) == l);
             REQUIRE(timeline->getClipPosition(splitted) == l + 4);
             REQUIRE(timeline->getClipPosition(cid3) == l + l - 5);
             REQUIRE(timeline->getClipPtr(cid2)->getIn() == 2);
             REQUIRE(timeline->getClipPtr(cid2)->getOut() == 5);
             REQUIRE(timeline->getClipPtr(splitted)->getIn() == 6);
             REQUIRE(timeline->getClipPtr(splitted)->getOut() == l - 4);
         };
         state2();
 
         undoStack->undo();
         state();
 
         undoStack->redo();
         state2();
     }
 
     SECTION("Split and resize")
     {
         REQUIRE(timeline->requestClipMove(cid1, tid1, 5));
         int l = timeline->getClipPlaytime(cid1);
         timeline->m_allClips[cid1]->m_endlessResize = false;
 
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipPlaytime(cid1) == l);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
         };
         state();
 
         REQUIRE(TimelineFunctions::requestClipCut(timeline, cid1, 9));
         int splitted = timeline->getClipByPosition(tid1, 10);
         timeline->m_allClips[splitted]->m_endlessResize = false;
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(splitted) == tid1);
             REQUIRE(timeline->getClipPlaytime(cid1) == 4);
             REQUIRE(timeline->getClipPlaytime(splitted) == l - 4);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(timeline->getClipPosition(splitted) == 9);
         };
         state2();
 
         REQUIRE(timeline->requestClipMove(splitted, tid2, 9, true, true));
         REQUIRE(timeline->requestItemResize(splitted, l - 3, true, true) == -1);
         REQUIRE(timeline->requestItemResize(splitted, l, false, true) == l);
         REQUIRE(timeline->requestItemResize(cid1, 5, false, true) == -1);
         REQUIRE(timeline->requestItemResize(cid1, l, true, true) == l);
         auto state3 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipTrackId(cid1) == tid1);
             REQUIRE(timeline->getClipTrackId(splitted) == tid2);
             REQUIRE(timeline->getClipPlaytime(cid1) == l);
             REQUIRE(timeline->getClipPlaytime(splitted) == l);
             REQUIRE(timeline->getClipPosition(cid1) == 5);
             REQUIRE(timeline->getClipPosition(splitted) == 5);
         };
         state3();
 
         undoStack->undo();
         undoStack->undo();
         undoStack->undo();
         state2();
         undoStack->undo();
         state();
         undoStack->redo();
         state2();
         undoStack->redo();
         undoStack->redo();
         undoStack->redo();
         state3();
     }
 
     SECTION("Clip splitting 2")
     {
         // More complex group structure split split
         int l = timeline->getClipPlaytime(cid2);
         REQUIRE(timeline->requestClipMove(cid1, tid1, 0));
         REQUIRE(timeline->requestClipMove(cid2, tid1, l));
         REQUIRE(timeline->requestClipMove(cid3, tid1, 2 * l));
         REQUIRE(timeline->requestClipMove(cid4, tid2, 0));
         REQUIRE(timeline->requestClipMove(cid5, tid2, l));
         REQUIRE(timeline->requestClipMove(cid6, tid2, 2 * l));
         REQUIRE(timeline->requestClipMove(cid7, tid1, 200));
         int gid1 = timeline->requestClipsGroup(std::unordered_set<int>({cid1, cid4}), true, GroupType::Normal);
         int gid2 = timeline->requestClipsGroup(std::unordered_set<int>({cid2, cid5}), true, GroupType::Normal);
         int gid3 = timeline->requestClipsGroup(std::unordered_set<int>({cid3, cid6}), true, GroupType::Normal);
         int gid4 = timeline->requestClipsGroup(std::unordered_set<int>({cid1, cid2, cid3, cid4, cid5, cid6, cid7}), true, GroupType::Normal);
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             int p = 0;
             for (int c : std::vector<int>({cid1, cid2, cid3})) {
                 REQUIRE(timeline->getClipPlaytime(c) == l);
                 REQUIRE(timeline->getClipTrackId(c) == tid1);
                 REQUIRE(timeline->getClipPosition(c) == p);
                 p += l;
             }
             p = 0;
             for (int c : std::vector<int>({cid4, cid5, cid6})) {
                 REQUIRE(timeline->getClipPlaytime(c) == l);
                 REQUIRE(timeline->getClipTrackId(c) == tid2);
                 REQUIRE(timeline->getClipPosition(c) == p);
                 p += l;
             }
             REQUIRE(timeline->getClipPosition(cid7) == 200);
             REQUIRE(timeline->getClipTrackId(cid7) == tid1);
             REQUIRE(timeline->m_groups->getDirectChildren(gid1) == std::unordered_set<int>({cid1, cid4}));
             REQUIRE(timeline->m_groups->getDirectChildren(gid2) == std::unordered_set<int>({cid2, cid5}));
             REQUIRE(timeline->m_groups->getDirectChildren(gid3) == std::unordered_set<int>({cid3, cid6}));
             REQUIRE(timeline->m_groups->getDirectChildren(gid4) == std::unordered_set<int>({gid1, gid2, gid3, cid7}));
             REQUIRE(timeline->getGroupElements(cid1) == std::unordered_set<int>({cid1, cid2, cid3, cid4, cid5, cid6, cid7}));
         };
         state();
 
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, 0));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, 5 * l));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, l));
         REQUIRE_FALSE(TimelineFunctions::requestClipCut(timeline, cid2, 2 * l));
         state();
 
         REQUIRE(TimelineFunctions::requestClipCut(timeline, cid2, l + 4));
         int splitted = timeline->getClipByPosition(tid1, l + 5);
         int splitted2 = timeline->getClipByPosition(tid2, l + 5);
         REQUIRE(splitted != splitted2);
         auto check_groups = [&]() {
             REQUIRE(timeline->m_groups->getDirectChildren(gid2) == std::unordered_set<int>({splitted, splitted2}));
             REQUIRE(timeline->m_groups->getDirectChildren(gid3) == std::unordered_set<int>({cid3, cid6}));
             REQUIRE(timeline->m_groups->getDirectChildren(gid4) == std::unordered_set<int>({gid2, gid3, cid7}));
             REQUIRE(timeline->getGroupElements(cid3) == std::unordered_set<int>({splitted, splitted2, cid3, cid6, cid7}));
 
             int g1b = timeline->m_groups->m_upLink[cid1];
             int g2b = timeline->m_groups->m_upLink[cid2];
             int g4b = timeline->m_groups->getRootId(cid1);
             REQUIRE(timeline->m_groups->getDirectChildren(g1b) == std::unordered_set<int>({cid1, cid4}));
             REQUIRE(timeline->m_groups->getDirectChildren(g2b) == std::unordered_set<int>({cid2, cid5}));
             REQUIRE(timeline->m_groups->getDirectChildren(g4b) == std::unordered_set<int>({g1b, g2b}));
             REQUIRE(timeline->getGroupElements(cid1) == std::unordered_set<int>({cid1, cid2, cid4, cid5}));
         };
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             int p = 0;
             for (int c : std::vector<int>({cid1, cid2, cid3})) {
                 REQUIRE(timeline->getClipPlaytime(c) == (c == cid2 ? 4 : l));
                 REQUIRE(timeline->getClipTrackId(c) == tid1);
                 REQUIRE(timeline->getClipPosition(c) == p);
                 p += l;
             }
             p = 0;
             for (int c : std::vector<int>({cid4, cid5, cid6})) {
                 REQUIRE(timeline->getClipPlaytime(c) == (c == cid5 ? 4 : l));
                 REQUIRE(timeline->getClipTrackId(c) == tid2);
                 REQUIRE(timeline->getClipPosition(c) == p);
                 p += l;
             }
             REQUIRE(timeline->getClipPosition(cid7) == 200);
             REQUIRE(timeline->getClipTrackId(cid7) == tid1);
             REQUIRE(timeline->getClipPosition(splitted) == l + 4);
             REQUIRE(timeline->getClipPlaytime(splitted) == l - 4);
             REQUIRE(timeline->getClipTrackId(splitted) == tid1);
             REQUIRE(timeline->getClipPosition(splitted2) == l + 4);
             REQUIRE(timeline->getClipPlaytime(splitted2) == l - 4);
             REQUIRE(timeline->getClipTrackId(splitted2) == tid2);
             check_groups();
         };
         state2();
 
         REQUIRE(timeline->requestClipMove(splitted, tid1, l + 4 + 10, true, true));
         REQUIRE(timeline->requestClipMove(cid1, tid2, 10, true, true));
         auto state3 = [&]() {
             REQUIRE(timeline->checkConsistency());
             int p = 0;
             for (int c : std::vector<int>({cid1, cid2, cid3})) {
                 REQUIRE(timeline->getClipPlaytime(c) == (c == cid2 ? 4 : l));
                 REQUIRE(timeline->getClipTrackId(c) == (c == cid3 ? tid1 : tid2));
                 REQUIRE(timeline->getClipPosition(c) == p + 10);
                 p += l;
             }
             p = 0;
             for (int c : std::vector<int>({cid4, cid5, cid6})) {
                 REQUIRE(timeline->getClipPlaytime(c) == (c == cid5 ? 4 : l));
                 REQUIRE(timeline->getClipTrackId(c) == (c == cid6 ? tid2 : tid3));
                 REQUIRE(timeline->getClipPosition(c) == p + 10);
                 p += l;
             }
             REQUIRE(timeline->getClipPosition(cid7) == 210);
             REQUIRE(timeline->getClipTrackId(cid7) == tid1);
             REQUIRE(timeline->getClipPosition(splitted) == l + 4 + 10);
             REQUIRE(timeline->getClipPlaytime(splitted) == l - 4);
             REQUIRE(timeline->getClipTrackId(splitted) == tid1);
             REQUIRE(timeline->getClipPosition(splitted2) == l + 4 + 10);
             REQUIRE(timeline->getClipPlaytime(splitted2) == l - 4);
             REQUIRE(timeline->getClipTrackId(splitted2) == tid2);
             check_groups();
         };
         state3();
 
         undoStack->undo();
         undoStack->undo();
         state2();
         undoStack->undo();
         state();
         undoStack->redo();
         state2();
         undoStack->redo();
         undoStack->redo();
         state3();
     }
 
     SECTION("Simple audio split")
     {
         int l = timeline->getClipPlaytime(audio1);
         REQUIRE(timeline->requestClipMove(audio1, tid1, 3));
 
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(audio1) == l);
             REQUIRE(timeline->getClipPosition(audio1) == 3);
             REQUIRE(timeline->getClipTrackId(audio1) == tid1);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
 
             REQUIRE(timeline->getGroupElements(audio1) == std::unordered_set<int>({audio1}));
         };
         state();
 
         REQUIRE(TimelineFunctions::requestSplitAudio(timeline, audio1, tid4));
         int splitted1 = timeline->getClipByPosition(tid4, 3);
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(audio1) == l);
             REQUIRE(timeline->getClipPosition(audio1) == 3);
             REQUIRE(timeline->getClipPlaytime(splitted1) == l);
             REQUIRE(timeline->getClipPosition(splitted1) == 3);
             REQUIRE(timeline->getClipTrackId(audio1) == tid1);
             REQUIRE(timeline->getClipTrackId(splitted1) == tid4);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 1);
             REQUIRE(timeline->getTrackClipsCount(tid4) == 1);
 
             REQUIRE(timeline->getGroupElements(audio1) == std::unordered_set<int>({audio1, splitted1}));
 
             int g1 = timeline->m_groups->getDirectAncestor(audio1);
             REQUIRE(timeline->m_groups->getDirectChildren(g1) == std::unordered_set<int>({audio1, splitted1}));
             REQUIRE(timeline->m_groups->getType(g1) == GroupType::AVSplit);
         };
         state2();
 
         undoStack->undo();
         state();
         undoStack->redo();
         state2();
         undoStack->undo();
         state();
         undoStack->redo();
         state2();
 
         // We also make sure that clips that are audio only cannot be further splitted
         REQUIRE(timeline->requestClipMove(cid1, tid1, l + 30));
         // This is a color clip, shouldn't be splittable
         REQUIRE_FALSE(TimelineFunctions::requestSplitAudio(timeline, cid1, tid2));
         // Check we cannot split audio on a video track
         REQUIRE_FALSE(TimelineFunctions::requestSplitAudio(timeline, audio1, tid2));
     }
     SECTION("Split audio on a selection")
     {
 
         int l = timeline->getClipPlaytime(audio2);
         REQUIRE(timeline->requestClipMove(audio1, tid1, 0));
         REQUIRE(timeline->requestClipMove(audio2, tid1, l));
         REQUIRE(timeline->requestClipMove(audio3, tid1, 2 * l));
 
         std::unordered_set<int> selection{audio1, audio3, audio2};
         REQUIRE(timeline->requestClipsGroup(selection, false, GroupType::Selection));
 
         auto state = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(audio1) == l);
             REQUIRE(timeline->getClipPlaytime(audio2) == l);
             REQUIRE(timeline->getClipPlaytime(audio3) == l);
             REQUIRE(timeline->getClipPosition(audio1) == 0);
             REQUIRE(timeline->getClipPosition(audio2) == l);
             REQUIRE(timeline->getClipPosition(audio3) == l + l);
             REQUIRE(timeline->getClipTrackId(audio1) == tid1);
             REQUIRE(timeline->getClipTrackId(audio2) == tid1);
             REQUIRE(timeline->getClipTrackId(audio3) == tid1);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
             REQUIRE(timeline->getTrackClipsCount(tid2) == 0);
 
             REQUIRE(timeline->getGroupElements(audio1) == std::unordered_set<int>({audio1, audio2, audio3}));
 
             int sel = timeline->m_temporarySelectionGroup;
             // check that selection is preserved
             REQUIRE(sel != -1);
             REQUIRE(timeline->m_groups->getType(sel) == GroupType::Selection);
         };
         state();
 
         REQUIRE(TimelineFunctions::requestSplitAudio(timeline, audio1, tid4));
         int splitted1 = timeline->getClipByPosition(tid4, 0);
         int splitted2 = timeline->getClipByPosition(tid4, l);
         int splitted3 = timeline->getClipByPosition(tid4, 2 * l);
         auto state2 = [&]() {
             REQUIRE(timeline->checkConsistency());
             REQUIRE(timeline->getClipPlaytime(audio1) == l);
             REQUIRE(timeline->getClipPlaytime(audio2) == l);
             REQUIRE(timeline->getClipPlaytime(audio3) == l);
             REQUIRE(timeline->getClipPosition(audio1) == 0);
             REQUIRE(timeline->getClipPosition(audio2) == l);
             REQUIRE(timeline->getClipPosition(audio3) == l + l);
             REQUIRE(timeline->getClipPlaytime(splitted1) == l);
             REQUIRE(timeline->getClipPlaytime(splitted2) == l);
             REQUIRE(timeline->getClipPlaytime(splitted3) == l);
             REQUIRE(timeline->getClipPosition(splitted1) == 0);
             REQUIRE(timeline->getClipPosition(splitted2) == l);
             REQUIRE(timeline->getClipPosition(splitted3) == l + l);
             REQUIRE(timeline->getClipTrackId(audio1) == tid1);
             REQUIRE(timeline->getClipTrackId(audio2) == tid1);
             REQUIRE(timeline->getClipTrackId(audio3) == tid1);
             REQUIRE(timeline->getClipTrackId(splitted1) == tid4);
             REQUIRE(timeline->getClipTrackId(splitted2) == tid4);
             REQUIRE(timeline->getClipTrackId(splitted3) == tid4);
             REQUIRE(timeline->getTrackClipsCount(tid1) == 3);
             REQUIRE(timeline->getTrackClipsCount(tid4) == 3);
 
             REQUIRE(timeline->getGroupElements(audio1) == std::unordered_set<int>({audio1, splitted1, audio2, audio3, splitted2, splitted3}));
 
             int sel = timeline->m_temporarySelectionGroup;
             // check that selection is preserved
             REQUIRE(sel != -1);
             REQUIRE(timeline->m_groups->getType(sel) == GroupType::Selection);
 
             REQUIRE(timeline->m_groups->getRootId(audio1) == sel);
             REQUIRE(timeline->m_groups->getDirectChildren(sel).size() == 3);
             REQUIRE(timeline->m_groups->getLeaves(sel).size() == 6);
 
             int g1 = timeline->m_groups->getDirectAncestor(audio1);
             int g2 = timeline->m_groups->getDirectAncestor(audio2);
             int g3 = timeline->m_groups->getDirectAncestor(audio3);
             REQUIRE(timeline->m_groups->getDirectChildren(sel) == std::unordered_set<int>({g1, g2, g3}));
             REQUIRE(timeline->m_groups->getDirectChildren(g1) == std::unordered_set<int>({audio1, splitted1}));
             REQUIRE(timeline->m_groups->getDirectChildren(g2) == std::unordered_set<int>({audio2, splitted2}));
             REQUIRE(timeline->m_groups->getDirectChildren(g3) == std::unordered_set<int>({audio3, splitted3}));
             REQUIRE(timeline->m_groups->getType(g1) == GroupType::AVSplit);
             REQUIRE(timeline->m_groups->getType(g2) == GroupType::AVSplit);
             REQUIRE(timeline->m_groups->getType(g3) == GroupType::AVSplit);
         };
         state2();
 
         undoStack->undo();
         state();
         undoStack->redo();
         state2();
     }
     binModel->clean();
     pCore->m_projectManager = nullptr;
     Logger::print_trace();
 }