diff --git a/src/core.cpp b/src/core.cpp
index cab067fac..c0595ff45 100644
--- a/src/core.cpp
+++ b/src/core.cpp
@@ -1,768 +1,768 @@
 /*
 Copyright (C) 2014  Till Theato <root@ttill.de>
 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 3 of the License, or
 (at your option) any later version.
 */
 
 #include "core.h"
 #include "bin/bin.h"
 #include "bin/projectitemmodel.h"
 #include "capture/mediacapture.h"
 #include "doc/docundostack.hpp"
 #include "doc/kdenlivedoc.h"
 #include "jobs/jobmanager.h"
 #include "kdenlive_debug.h"
 #include "kdenlivesettings.h"
 #include "library/librarywidget.h"
 #include "mainwindow.h"
 #include "mltconnection.h"
 #include "mltcontroller/clipcontroller.h"
 #include "monitor/monitormanager.h"
 #include "profiles/profilemodel.hpp"
 #include "profiles/profilerepository.hpp"
 #include "project/projectmanager.h"
 #include "timeline2/model/timelineitemmodel.hpp"
 #include "timeline2/view/timelinecontroller.h"
 #include "timeline2/view/timelinewidget.h"
 
 #include <mlt++/MltRepository.h>
 
 #include <KMessageBox>
 #include <QCoreApplication>
 #include <QInputDialog>
 #include <QDir>
 
 #include <mlt++/MltRepository.h>
 
 #include <locale>
 #ifdef Q_OS_MAC
 #include <xlocale.h>
 #endif
 
 std::unique_ptr<Core> Core::m_self;
 Core::Core()
     : m_thumbProfile(nullptr)
     , m_capture(new MediaCapture(this))
 {
 }
 
 void Core::prepareShutdown()
 {
     m_guiConstructed = false;
     QThreadPool::globalInstance()->clear();
 }
 
 Core::~Core()
 {
     qDebug() << "deleting core";
     if (m_monitorManager) {
         delete m_monitorManager;
     }
     // delete m_binWidget;
     if (m_projectManager) {
         delete m_projectManager;
     }
     ClipController::mediaUnavailable.reset();
 }
 
 void Core::build(bool isAppImage, const QString &MltPath)
 {
     if (m_self) {
         return;
     }
     m_self.reset(new Core());
     m_self->initLocale();
 
     qRegisterMetaType<audioShortVector>("audioShortVector");
     qRegisterMetaType<QVector<double>>("QVector<double>");
     qRegisterMetaType<MessageType>("MessageType");
     qRegisterMetaType<stringMap>("stringMap");
     qRegisterMetaType<audioByteArray>("audioByteArray");
     qRegisterMetaType<QList<ItemInfo>>("QList<ItemInfo>");
     qRegisterMetaType<std::shared_ptr<Mlt::Producer>>("std::shared_ptr<Mlt::Producer>");
     qRegisterMetaType<QVector<int>>();
     qRegisterMetaType<QDomElement>("QDomElement");
     qRegisterMetaType<requestClipInfo>("requestClipInfo");
     
     if (isAppImage) {
         QString appPath = qApp->applicationDirPath();
         KdenliveSettings::setFfmpegpath(QDir::cleanPath(appPath + QStringLiteral("/ffmpeg")));
         KdenliveSettings::setFfplaypath(QDir::cleanPath(appPath + QStringLiteral("/ffplay")));
         KdenliveSettings::setFfprobepath(QDir::cleanPath(appPath + QStringLiteral("/ffprobe")));
         KdenliveSettings::setRendererpath(QDir::cleanPath(appPath + QStringLiteral("/melt")));
         MltConnection::construct(QDir::cleanPath(appPath + QStringLiteral("/../share/mlt/profiles")));
     } else {
         // Open connection with Mlt
         MltConnection::construct(MltPath);
     }
 
     // load the profile from disk
     ProfileRepository::get()->refresh();
     // load default profile
     m_self->m_profile = KdenliveSettings::default_profile();
     if (m_self->m_profile.isEmpty()) {
         m_self->m_profile = ProjectManager::getDefaultProjectFormat();
         KdenliveSettings::setDefault_profile(m_self->m_profile);
     }
 
     // Init producer shown for unavailable media
     // TODO make it a more proper image, it currently causes a crash on exit
     ClipController::mediaUnavailable = std::make_shared<Mlt::Producer>(ProfileRepository::get()->getProfile(m_self->m_profile)->profile(), "color:blue");
     ClipController::mediaUnavailable->set("length", 99999999);
 
     m_self->m_projectItemModel = ProjectItemModel::construct();
     // Job manager must be created before bin to correctly connect
     m_self->m_jobManager.reset(new JobManager(m_self.get()));
 }
 
 void Core::initGUI(const QUrl &Url)
 {
     m_guiConstructed = true;
     m_profile = KdenliveSettings::default_profile();
     m_currentProfile = m_profile;
     profileChanged();
     m_mainWindow = new MainWindow();
     connect(this, &Core::showConfigDialog, m_mainWindow, &MainWindow::slotPreferences);
 
     // load default profile and ask user to select one if not found.
     if (m_profile.isEmpty()) {
         m_profile = ProjectManager::getDefaultProjectFormat();
         profileChanged();
         KdenliveSettings::setDefault_profile(m_profile);
     }
 
     if (!ProfileRepository::get()->profileExists(m_profile)) {
         KMessageBox::sorry(m_mainWindow, i18n("The default profile of Kdenlive is not set or invalid, press OK to set it to a correct value."));
 
         // TODO this simple widget should be improved and probably use profileWidget
         // we get the list of profiles
         QVector<QPair<QString, QString>> all_profiles = ProfileRepository::get()->getAllProfiles();
         QStringList all_descriptions;
         for (const auto &profile : all_profiles) {
             all_descriptions << profile.first;
         }
 
         // ask the user
         bool ok;
         QString item = QInputDialog::getItem(m_mainWindow, i18n("Select Default Profile"), i18n("Profile:"), all_descriptions, 0, false, &ok);
         if (ok) {
             ok = false;
             for (const auto &profile : all_profiles) {
                 if (profile.first == item) {
                     m_profile = profile.second;
                     ok = true;
                 }
             }
         }
         if (!ok) {
             KMessageBox::error(
                 m_mainWindow,
                 i18n("The given profile is invalid. We default to the profile \"dv_pal\", but you can change this from Kdenlive's settings panel"));
             m_profile = QStringLiteral("dv_pal");
         }
         KdenliveSettings::setDefault_profile(m_profile);
         profileChanged();
     }
 
     m_projectManager = new ProjectManager(this);
     m_binWidget = new Bin(m_projectItemModel, m_mainWindow);
     m_library = new LibraryWidget(m_projectManager, m_mainWindow);
     connect(m_library, SIGNAL(addProjectClips(QList<QUrl>)), m_binWidget, SLOT(droppedUrls(QList<QUrl>)));
     connect(this, &Core::updateLibraryPath, m_library, &LibraryWidget::slotUpdateLibraryPath);
     m_monitorManager = new MonitorManager(this);
     // Producer queue, creating MLT::Producers on request
     /*
     m_producerQueue = new ProducerQueue(m_binController);
     connect(m_producerQueue, &ProducerQueue::gotFileProperties, m_binWidget, &Bin::slotProducerReady);
     connect(m_producerQueue, &ProducerQueue::replyGetImage, m_binWidget, &Bin::slotThumbnailReady);
     connect(m_producerQueue, &ProducerQueue::requestProxy,
             [this](const QString &id){ m_binWidget->startJob(id, AbstractClipJob::PROXYJOB);});
     connect(m_producerQueue, &ProducerQueue::removeInvalidClip, m_binWidget, &Bin::slotRemoveInvalidClip, Qt::DirectConnection);
     connect(m_producerQueue, SIGNAL(addClip(QString, QMap<QString, QString>)), m_binWidget, SLOT(slotAddUrl(QString, QMap<QString, QString>)));
     connect(m_binController.get(), SIGNAL(createThumb(QDomElement, QString, int)), m_producerQueue, SLOT(getFileProperties(QDomElement, QString, int)));
     connect(m_binWidget, &Bin::producerReady, m_producerQueue, &ProducerQueue::slotProcessingDone, Qt::DirectConnection);
     // TODO
     connect(m_producerQueue, SIGNAL(removeInvalidProxy(QString,bool)), m_binWidget, SLOT(slotRemoveInvalidProxy(QString,bool)));*/
 
     m_mainWindow->init();
     projectManager()->init(Url, QString());
     if (qApp->isSessionRestored()) {
         // NOTE: we are restoring only one window, because Kdenlive only uses one MainWindow
         m_mainWindow->restore(1, false);
     }
     QMetaObject::invokeMethod(pCore->projectManager(), "slotLoadOnOpen", Qt::QueuedConnection);
     m_mainWindow->show();
     QThreadPool::globalInstance()->setMaxThreadCount(qMin(4, QThreadPool::globalInstance()->maxThreadCount()));
 }
 
 std::unique_ptr<Core> &Core::self()
 {
     if (!m_self) {
         qDebug() << "Error : Core has not been created";
     }
     return m_self;
 }
 
 MainWindow *Core::window()
 {
     return m_mainWindow;
 }
 
 ProjectManager *Core::projectManager()
 {
     return m_projectManager;
 }
 
 MonitorManager *Core::monitorManager()
 {
     return m_monitorManager;
 }
 
 Monitor *Core::getMonitor(int id)
 {
     if (id == Kdenlive::ClipMonitor) {
         return m_monitorManager->clipMonitor();
     }
     return m_monitorManager->projectMonitor();
 }
 
 Bin *Core::bin()
 {
     return m_binWidget;
 }
 
 void Core::selectBinClip(const QString &clipId, int frame, const QPoint &zone)
 {
     m_binWidget->selectClipById(clipId, frame, zone);
 }
 
 std::shared_ptr<JobManager> Core::jobManager()
 {
     return m_jobManager;
 }
 
 LibraryWidget *Core::library()
 {
     return m_library;
 }
 
 void Core::initLocale()
 {
     QLocale systemLocale = QLocale();
 #ifndef Q_OS_MAC
     setlocale(LC_NUMERIC, nullptr);
 #else
     setlocale(LC_NUMERIC_MASK, nullptr);
 #endif
 
 // localeconv()->decimal_point does not give reliable results on Windows
 #ifndef Q_OS_WIN
     char *separator = localeconv()->decimal_point;
     if (QString::fromUtf8(separator) != QChar(systemLocale.decimalPoint())) {
         // qCDebug(KDENLIVE_LOG)<<"------\n!!! system locale is not similar to Qt's locale... be prepared for bugs!!!\n------";
         // HACK: There is a locale conflict, so set locale to C
         // Make sure to override exported values or it won't work
         qputenv("LANG", "C");
 #ifndef Q_OS_MAC
         setlocale(LC_NUMERIC, "C");
 #else
         setlocale(LC_NUMERIC_MASK, "C");
 #endif
         systemLocale = QLocale::c();
     }
 #endif
 
     systemLocale.setNumberOptions(QLocale::OmitGroupSeparator);
     QLocale::setDefault(systemLocale);
 }
 
 std::unique_ptr<Mlt::Repository> &Core::getMltRepository()
 {
     return MltConnection::self()->getMltRepository();
 }
 
 std::unique_ptr<ProfileModel> &Core::getCurrentProfile() const
 {
     return ProfileRepository::get()->getProfile(m_currentProfile);
 }
 
 const QString &Core::getCurrentProfilePath() const
 {
     return m_currentProfile;
 }
 
 bool Core::setCurrentProfile(const QString &profilePath)
 {
     if (m_currentProfile == profilePath) {
         // no change required
         return true;
     }
     if (ProfileRepository::get()->profileExists(profilePath)) {
         m_currentProfile = profilePath;
         m_thumbProfile.reset();
         // inform render widget
         profileChanged();
         m_mainWindow->updateRenderWidgetProfile();
         if (m_guiConstructed && m_mainWindow->getCurrentTimeline()->controller()->getModel()) {
             m_mainWindow->getCurrentTimeline()->controller()->getModel()->updateProfile(&getCurrentProfile()->profile());
             checkProfileValidity();
         }
         return true;
     }
     return false;
 }
 
 void Core::checkProfileValidity()
 {
     int offset = (getCurrentProfile()->profile().width() % 8) + (getCurrentProfile()->profile().height() % 2);
     if (offset > 0) {
         // Profile is broken, warn user
         if (m_binWidget) {
             m_binWidget->displayBinMessage(i18n("Your project profile is invalid, rendering might fail."), KMessageWidget::Warning);
         }
     }
 }
 
 double Core::getCurrentSar() const
 {
     return getCurrentProfile()->sar();
 }
 
 double Core::getCurrentDar() const
 {
     return getCurrentProfile()->dar();
 }
 
 double Core::getCurrentFps() const
 {
     return getCurrentProfile()->fps();
 }
 
 QSize Core::getCurrentFrameDisplaySize() const
 {
     return {(int)(getCurrentProfile()->height() * getCurrentDar() + 0.5), getCurrentProfile()->height()};
 }
 
 QSize Core::getCurrentFrameSize() const
 {
     return {getCurrentProfile()->width(), getCurrentProfile()->height()};
 }
 
 void Core::requestMonitorRefresh()
 {
     if (!m_guiConstructed) return;
     m_monitorManager->refreshProjectMonitor();
 }
 
 void Core::refreshProjectRange(QSize range)
 {
     if (!m_guiConstructed) return;
     m_monitorManager->refreshProjectRange(range);
 }
 
 int Core::getItemPosition(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipPosition(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getCompositionPosition(id.second);
         }
         break;
     case ObjectType::BinClip:
     case ObjectType::TimelineTrack:
         return 0;
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 int Core::getItemIn(const ObjectId &id)
 {
     if (!m_guiConstructed || !m_mainWindow->getCurrentTimeline() || !m_mainWindow->getCurrentTimeline()->controller()->getModel()) {
         qDebug() << "/ / // QUERYING ITEM IN BUT GUI NOT BUILD!!";
         return 0;
     }
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipIn(id.second);
         } else {
             qDebug()<<"// ERROR QUERYING NON CLIP PROPERTIES\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!";
         }
         break;
     case ObjectType::TimelineComposition:
     case ObjectType::BinClip:
     case ObjectType::TimelineTrack:
         return 0;
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 PlaylistState::ClipState Core::getItemState(const ObjectId &id)
 {
     if (!m_guiConstructed) return PlaylistState::Disabled;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipState(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         return PlaylistState::VideoOnly;
         break;
     case ObjectType::BinClip:
         return m_binWidget->getClipState(id.second);
         break;
     case ObjectType::TimelineTrack:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->isAudioTrack(id.second) ? PlaylistState::AudioOnly : PlaylistState::VideoOnly;
     default:
         qDebug() << "ERROR: unhandled object type";
         break;
     }
     return PlaylistState::Disabled;
 }
 
 int Core::getItemDuration(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipPlaytime(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getCompositionPlaytime(id.second);
         }
         break;
     case ObjectType::BinClip:
         return (int)m_binWidget->getClipDuration(id.second);
         break;
     case ObjectType::TimelineTrack:
         return m_mainWindow->getCurrentTimeline()->controller()->duration();
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 int Core::getItemTrack(const ObjectId &id)
 {
     if (!m_guiConstructed) return 0;
     switch (id.first) {
     case ObjectType::TimelineClip:
     case ObjectType::TimelineComposition:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getItemTrackId(id.second);
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
     return 0;
 }
 
 void Core::refreshProjectItem(const ObjectId &id)
 {
     if (!m_guiConstructed || m_mainWindow->getCurrentTimeline()->loading) return;
     switch (id.first) {
     case ObjectType::TimelineClip:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(id.second)) {
             m_mainWindow->getCurrentTimeline()->controller()->refreshItem(id.second);
         }
         break;
     case ObjectType::TimelineComposition:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isComposition(id.second)) {
             m_mainWindow->getCurrentTimeline()->controller()->refreshItem(id.second);
         }
         break;
     case ObjectType::TimelineTrack:
         if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isTrack(id.second)) {
             requestMonitorRefresh();
         }
         break;
     case ObjectType::BinClip:
         m_monitorManager->refreshClipMonitor();
         break;
     default:
         qDebug() << "ERROR: unhandled object type";
     }
 }
 
 bool Core::hasTimelinePreview() const
 {
     if (!m_guiConstructed) {
         return false;
     }
     return m_mainWindow->getCurrentTimeline()->controller()->renderedChunks().size() > 0;
 }
 
 KdenliveDoc *Core::currentDoc()
 {
     return m_projectManager->current();
 }
 
 int Core::projectDuration() const
 {
     if (!m_guiConstructed) {
         return 0;
     }
     return m_mainWindow->getCurrentTimeline()->controller()->duration();
 }
 
 void Core::profileChanged()
 {
     GenTime::setFps(getCurrentFps());
 }
 
 void Core::pushUndo(const Fun &undo, const Fun &redo, const QString &text)
 {
     undoStack()->push(new FunctionalUndoCommand(undo, redo, text));
 }
 
 void Core::pushUndo(QUndoCommand *command)
 {
     undoStack()->push(command);
 }
 
 void Core::displayMessage(const QString &message, MessageType type, int timeout)
 {
     if (m_mainWindow) {
         m_mainWindow->displayMessage(message, type, timeout);
     } else {
         qDebug() << message;
     }
 }
 
 void Core::displayBinMessage(const QString &text, int type, const QList<QAction *> &actions)
 {
     m_binWidget->doDisplayMessage(text, (KMessageWidget::MessageType)type, actions);
 }
 
 void Core::displayBinLogMessage(const QString &text, int type, const QString &logInfo)
 {
     m_binWidget->doDisplayMessage(text, (KMessageWidget::MessageType)type, logInfo);
 }
 
 void Core::clearAssetPanel(int itemId)
 {
     if (m_guiConstructed) m_mainWindow->clearAssetPanel(itemId);
 }
 
 std::shared_ptr<EffectStackModel> Core::getItemEffectStack(int itemType, int itemId)
 {
     if (!m_guiConstructed) return nullptr;
     switch (itemType) {
     case (int)ObjectType::TimelineClip:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipEffectStack(itemId);
     case (int)ObjectType::TimelineTrack:
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getTrackEffectStackModel(itemId);
         break;
     case (int)ObjectType::BinClip:
         return m_binWidget->getClipEffectStack(itemId);
     default:
         return nullptr;
     }
 }
 
 std::shared_ptr<DocUndoStack> Core::undoStack()
 {
     return projectManager()->undoStack();
 }
 
 QMap<int, QString> Core::getVideoTrackNames()
 {
     if (!m_guiConstructed) return QMap<int, QString>();
     return m_mainWindow->getCurrentTimeline()->controller()->getTrackNames(true);
 }
 
 QPair<int, int> Core::getCompositionATrack(int cid) const
 {
     if (!m_guiConstructed) return {};
     return m_mainWindow->getCurrentTimeline()->controller()->getCompositionATrack(cid);
 }
 
 bool Core::compositionAutoTrack(int cid) const
 {
     return m_mainWindow->getCurrentTimeline()->controller()->compositionAutoTrack(cid);
 }
 
 void Core::setCompositionATrack(int cid, int aTrack)
 {
     if (!m_guiConstructed) return;
     m_mainWindow->getCurrentTimeline()->controller()->setCompositionATrack(cid, aTrack);
 }
 
 std::shared_ptr<ProjectItemModel> Core::projectItemModel()
 {
     return m_projectItemModel;
 }
 
 void Core::invalidateRange(QSize range)
 {
     if (!m_mainWindow || m_mainWindow->getCurrentTimeline()->loading) return;
     m_mainWindow->getCurrentTimeline()->controller()->invalidateZone(range.width(), range.height());
 }
 
 void Core::invalidateItem(ObjectId itemId)
 {
-    if (!m_mainWindow || m_mainWindow->getCurrentTimeline()->loading) return;
+    if (!m_mainWindow || !m_mainWindow->getCurrentTimeline() || m_mainWindow->getCurrentTimeline()->loading) return;
     switch (itemId.first) {
     case ObjectType::TimelineClip:
     case ObjectType::TimelineComposition:
         m_mainWindow->getCurrentTimeline()->controller()->invalidateItem(itemId.second);
         break;
     case ObjectType::TimelineTrack:
         m_mainWindow->getCurrentTimeline()->controller()->invalidateTrack(itemId.second);
         break;
     case ObjectType::BinClip:
         m_binWidget->invalidateClip(QString::number(itemId.second));
         break;
     default:
         // compositions should not have effects
         break;
     }
 }
 
 double Core::getClipSpeed(int id) const
 {
     return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipSpeed(id);
 }
 
 void Core::updateItemKeyframes(ObjectId id)
 {
     if (id.first == ObjectType::TimelineClip && m_mainWindow) {
         m_mainWindow->getCurrentTimeline()->controller()->updateClip(id.second, {TimelineModel::KeyframesRole});
     }
 }
 
 void Core::updateItemModel(ObjectId id, const QString &service)
 {
-    if (m_mainWindow && !m_mainWindow->getCurrentTimeline()->loading && service.startsWith(QLatin1String("fade")) && id.first == ObjectType::TimelineClip) {
+    if (m_mainWindow && id.first == ObjectType::TimelineClip && !m_mainWindow->getCurrentTimeline()->loading && service.startsWith(QLatin1String("fade"))) {
         bool startFade = service == QLatin1String("fadein") || service == QLatin1String("fade_from_black");
         m_mainWindow->getCurrentTimeline()->controller()->updateClip(id.second, {startFade ? TimelineModel::FadeInRole : TimelineModel::FadeOutRole});
     }
 }
 
 void Core::showClipKeyframes(ObjectId id, bool enable)
 {
     if (id.first == ObjectType::TimelineClip) {
         m_mainWindow->getCurrentTimeline()->controller()->showClipKeyframes(id.second, enable);
     } else if (id.first == ObjectType::TimelineComposition) {
         m_mainWindow->getCurrentTimeline()->controller()->showCompositionKeyframes(id.second, enable);
     }
 }
 
 Mlt::Profile *Core::thumbProfile()
 {
     QMutexLocker lck(&m_thumbProfileMutex);
     if (!m_thumbProfile) {
         m_thumbProfile = std::make_unique<Mlt::Profile>(m_currentProfile.toStdString().c_str());
         m_thumbProfile->set_height(144);
         int width = 144 * m_thumbProfile->dar() + 0.5;
         if (width % 8 > 0) {
             width += 8 - width % 8;
         }
         m_thumbProfile->set_width(width);
     }
     return m_thumbProfile.get();
 }
 
 int Core::getTimelinePosition() const
 {
     if (m_mainWindow && m_guiConstructed) {
         return m_mainWindow->getCurrentTimeline()->controller()->timelinePosition();
     }
     return 0;
 }
 
 void Core::triggerAction(const QString &name)
 {
     QAction *action = m_mainWindow->actionCollection()->action(name);
     if (action) {
         action->trigger();
     }
 }
 
 void Core::clean()
 {
     m_self.reset();
 }
 
 void Core::startMediaCapture(bool checkAudio, bool checkVideo)
 {
     if (checkAudio && checkVideo) {
         m_capture->recordVideo(true);
     } else if (checkAudio) {
         m_capture->recordAudio(true);
     }
     m_mediaCaptureFile = m_capture->getCaptureOutputLocation();
 }
 
 void Core::stopMediaCapture(bool checkAudio, bool checkVideo)
 {
     if (checkAudio && checkVideo) {
         m_capture->recordVideo(false);
     } else if (checkAudio) {
         m_capture->recordAudio(false);
     }
 }
 
 QStringList Core::getAudioCaptureDevices()
 {
     return m_capture->getAudioCaptureDevices();
 }
 
 int Core::getMediaCaptureState()
 {
     return m_capture->getState();
 }
 
 bool Core::isMediaCapturing()
 {
     return m_capture->isRecording();
 }
 
 MediaCapture *Core::getAudioDevice()
 {
     return m_capture.get();
 }
 
 QString Core::getProjectFolderName()
 {
     return m_monitorManager->getProjectFolder();
 }
 
 QString Core::getTimelineClipBinId(int cid)
 {
     if (!m_guiConstructed) {
         return QString();
     }
     if (m_mainWindow->getCurrentTimeline()->controller()->getModel()->isClip(cid)) {
         return m_mainWindow->getCurrentTimeline()->controller()->getModel()->getClipBinId(cid);
     }
     return QString();
 }
 
 int Core::getDurationFromString(const QString &time)
 {
     if (!m_guiConstructed) {
         return 0;
     }
     const QString duration = currentDoc()->timecode().reformatSeparators(time);
     return currentDoc()->timecode().getFrameCount(duration);
 }
diff --git a/src/effects/effectstack/model/effectstackmodel.cpp b/src/effects/effectstack/model/effectstackmodel.cpp
index 53745833f..74bed4b35 100644
--- a/src/effects/effectstack/model/effectstackmodel.cpp
+++ b/src/effects/effectstack/model/effectstackmodel.cpp
@@ -1,1199 +1,1219 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Nicolas Carion                                  *
  *   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 "effectstackmodel.hpp"
 #include "assets/keyframes/model/keyframemodellist.hpp"
 #include "core.h"
 #include "doc/docundostack.hpp"
 #include "effectgroupmodel.hpp"
 #include "effectitemmodel.hpp"
 #include "effects/effectsrepository.hpp"
 #include "macros.hpp"
 #include "timeline2/model/timelinemodel.hpp"
 #include <profiles/profilemodel.hpp>
 #include <stack>
 #include <utility>
 #include <vector>
 
 EffectStackModel::EffectStackModel(std::weak_ptr<Mlt::Service> service, ObjectId ownerId, std::weak_ptr<DocUndoStack> undo_stack)
     : AbstractTreeModel()
     , m_effectStackEnabled(true)
     , m_ownerId(std::move(ownerId))
     , m_undoStack(std::move(undo_stack))
     , m_lock(QReadWriteLock::Recursive)
     , m_loadingExisting(false)
 {
     m_masterService = std::move(service);
 }
 
 std::shared_ptr<EffectStackModel> EffectStackModel::construct(std::weak_ptr<Mlt::Service> service, ObjectId ownerId, std::weak_ptr<DocUndoStack> undo_stack)
 {
     std::shared_ptr<EffectStackModel> self(new EffectStackModel(std::move(service), ownerId, std::move(undo_stack)));
     self->rootItem = EffectGroupModel::construct(QStringLiteral("root"), self, true);
     return self;
 }
 
 void EffectStackModel::resetService(std::weak_ptr<Mlt::Service> service)
 {
     QWriteLocker locker(&m_lock);
     m_masterService = std::move(service);
     m_childServices.clear();
     // replant all effects in new service
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::static_pointer_cast<EffectItemModel>(rootItem->child(i))->plant(m_masterService);
     }
 }
 
 void EffectStackModel::addService(std::weak_ptr<Mlt::Service> service)
 {
     QWriteLocker locker(&m_lock);
     m_childServices.emplace_back(std::move(service));
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::static_pointer_cast<EffectItemModel>(rootItem->child(i))->plantClone(m_childServices.back());
     }
 }
 
 void EffectStackModel::loadService(std::weak_ptr<Mlt::Service> service)
 {
     QWriteLocker locker(&m_lock);
     m_childServices.emplace_back(std::move(service));
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::static_pointer_cast<EffectItemModel>(rootItem->child(i))->loadClone(m_childServices.back());
     }
 }
 
 void EffectStackModel::removeService(const std::shared_ptr<Mlt::Service> &service)
 {
     QWriteLocker locker(&m_lock);
     std::vector<int> to_delete;
     for (int i = int(m_childServices.size()) - 1; i >= 0; --i) {
         auto ptr = m_childServices[uint(i)].lock();
         if (service->get_int("_childid") == ptr->get_int("_childid")) {
             for (int j = 0; j < rootItem->childCount(); ++j) {
                 std::static_pointer_cast<EffectItemModel>(rootItem->child(j))->unplantClone(ptr);
             }
             to_delete.push_back(i);
         }
     }
     for (int i : to_delete) {
         m_childServices.erase(m_childServices.begin() + i);
     }
 }
 
 void EffectStackModel::removeCurrentEffect()
 {
     int ix = 0;
     if (auto ptr = m_masterService.lock()) {
         ix = ptr->get_int("kdenlive:activeeffect");
     }
     if (ix < 0) {
         return;
     }
     std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
     if (effect) {
         removeEffect(effect);
     }
 }
 
 void EffectStackModel::removeEffect(const std::shared_ptr<EffectItemModel> &effect)
 {
     qDebug() << "* * ** REMOVING EFFECT FROM STACK!!!\n!!!!!!!!!";
     QWriteLocker locker(&m_lock);
     Q_ASSERT(m_allItems.count(effect->getId()) > 0);
     int parentId = -1;
     if (auto ptr = effect->parentItem().lock()) parentId = ptr->getId();
     int current = 0;
     if (auto srv = m_masterService.lock()) {
         current = srv->get_int("kdenlive:activeeffect");
         if (current >= rootItem->childCount() - 1) {
             srv->set("kdenlive:activeeffect", --current);
         }
     }
     int currentRow = effect->row();
     Fun undo = addItem_lambda(effect, parentId);
     if (currentRow != rowCount() - 1) {
         Fun move = moveItem_lambda(effect->getId(), currentRow, true);
         PUSH_LAMBDA(move, undo);
     }
     Fun redo = removeItem_lambda(effect->getId());
     bool res = redo();
     if (res) {
         int inFades = int(m_fadeIns.size());
         int outFades = int(m_fadeOuts.size());
         m_fadeIns.erase(effect->getId());
         m_fadeOuts.erase(effect->getId());
         inFades = int(m_fadeIns.size()) - inFades;
         outFades = int(m_fadeOuts.size()) - outFades;
         QString effectName = EffectsRepository::get()->getName(effect->getAssetId());
         Fun update = [this, current, inFades, outFades]() {
             // Required to build the effect view
             if (current < 0 || rowCount() == 0) {
                 // Stack is now empty
                 emit dataChanged(QModelIndex(), QModelIndex(), {});
             } else {
                 QVector<int> roles = {TimelineModel::EffectNamesRole};
                 if (inFades < 0) {
                     roles << TimelineModel::FadeInRole;
                 }
                 if (outFades < 0) {
                     roles << TimelineModel::FadeOutRole;
                 }
                 qDebug() << "// EMITTING UNDO DATA CHANGE: " << roles;
                 emit dataChanged(QModelIndex(), QModelIndex(), roles);
             }
             // TODO: only update if effect is fade or keyframe
             /*if (inFades < 0) {
                 pCore->updateItemModel(m_ownerId, QStringLiteral("fadein"));
             } else if (outFades < 0) {
                 pCore->updateItemModel(m_ownerId, QStringLiteral("fadeout"));
             }*/
             pCore->updateItemKeyframes(m_ownerId);
             return true;
         };
         Fun update2 = [this, inFades, outFades]() {
             // Required to build the effect view
             QVector<int> roles = {TimelineModel::EffectNamesRole};
             // TODO: only update if effect is fade or keyframe
             if (inFades < 0) {
                 roles << TimelineModel::FadeInRole;
             } else if (outFades < 0) {
                 roles << TimelineModel::FadeOutRole;
             }
             qDebug() << "// EMITTING REDO DATA CHANGE: " << roles;
             emit dataChanged(QModelIndex(), QModelIndex(), roles);
             pCore->updateItemKeyframes(m_ownerId);
             return true;
         };
         update();
         PUSH_LAMBDA(update, redo);
         PUSH_LAMBDA(update2, undo);
         PUSH_UNDO(undo, redo, i18n("Delete effect %1", effectName));
     } else {
         qDebug() << "..........FAILED EFFECT DELETION";
     }
 }
 
 bool EffectStackModel::copyXmlEffect(QDomElement effect)
 {
     std::function<bool(void)> undo = []() { return true; };
     std::function<bool(void)> redo = []() { return true; };
     bool result = fromXml(effect, undo, redo);
     if (result) {
         PUSH_UNDO(undo, redo, i18n("Copy effect"));
     }
     return result;
 }
 
 QDomElement EffectStackModel::toXml(QDomDocument &document)
 {
     QDomElement container = document.createElement(QStringLiteral("effects"));
     int currentIn = pCore->getItemIn(m_ownerId);
     container.setAttribute(QStringLiteral("parentIn"), currentIn);
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
         QDomElement sub = document.createElement(QStringLiteral("effect"));
         sub.setAttribute(QStringLiteral("id"), sourceEffect->getAssetId());
         int filterIn = sourceEffect->filter().get_int("in");
         int filterOut = sourceEffect->filter().get_int("out");
         if (filterOut > filterIn) {
             sub.setAttribute(QStringLiteral("in"), filterIn);
             sub.setAttribute(QStringLiteral("out"), filterOut);
         }
         QStringList passProps {QStringLiteral("disable"), QStringLiteral("kdenlive:collapsed")};
         for (const QString &param : passProps) {
             int paramVal = sourceEffect->filter().get_int(param.toUtf8().constData());
             if (paramVal > 0) {
                 Xml::setXmlProperty(sub, param, QString::number(paramVal));
             }
         }
         QVector<QPair<QString, QVariant>> params = sourceEffect->getAllParameters();
         QLocale locale;
         for (const auto &param : params) {
             if (param.second.type() == QVariant::Double) {
                 Xml::setXmlProperty(sub, param.first, locale.toString(param.second.toDouble()));
             } else {
                 Xml::setXmlProperty(sub, param.first, param.second.toString());
             }
         }
         container.appendChild(sub);
     }
     return container;
 }
 
 QDomElement EffectStackModel::rowToXml(int row, QDomDocument &document)
 {
     QDomElement container = document.createElement(QStringLiteral("effects"));
     if (row < 0 || row >= rootItem->childCount()) {
         return container;
     }
     int currentIn = pCore->getItemIn(m_ownerId);
     container.setAttribute(QStringLiteral("parentIn"), currentIn);
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(row));
     QDomElement sub = document.createElement(QStringLiteral("effect"));
     sub.setAttribute(QStringLiteral("id"), sourceEffect->getAssetId());
     int filterIn = sourceEffect->filter().get_int("in");
     int filterOut = sourceEffect->filter().get_int("out");
     if (filterOut > filterIn) {
         sub.setAttribute(QStringLiteral("in"), filterIn);
         sub.setAttribute(QStringLiteral("out"), filterOut);
     }
     QStringList passProps {QStringLiteral("disable"), QStringLiteral("kdenlive:collapsed")};
     for (const QString &param : passProps) {
         int paramVal = sourceEffect->filter().get_int(param.toUtf8().constData());
         if (paramVal > 0) {
             Xml::setXmlProperty(sub, param, QString::number(paramVal));
         }
     }
     QVector<QPair<QString, QVariant>> params = sourceEffect->getAllParameters();
     QLocale locale;
     for (const auto &param : params) {
         if (param.second.type() == QVariant::Double) {
             Xml::setXmlProperty(sub, param.first, locale.toString(param.second.toDouble()));
         } else {
             Xml::setXmlProperty(sub, param.first, param.second.toString());
         }
     }
     container.appendChild(sub);
     return container;
 }
 
 bool EffectStackModel::fromXml(const QDomElement &effectsXml, Fun &undo, Fun &redo)
 {
     QDomNodeList nodeList = effectsXml.elementsByTagName(QStringLiteral("effect"));
     int parentIn = effectsXml.attribute(QStringLiteral("parentIn")).toInt();
     qDebug()<<"// GOT PREVIOUS PARENTIN: "<<parentIn<<"\n\n=======\n=======\n\n";
     int currentIn = pCore->getItemIn(m_ownerId);
     PlaylistState::ClipState state = pCore->getItemState(m_ownerId);
     for (int i = 0; i < nodeList.count(); ++i) {
         QDomElement node = nodeList.item(i).toElement();
         const QString effectId = node.attribute(QStringLiteral("id"));
         EffectType type = EffectsRepository::get()->getType(effectId);
         bool isAudioEffect = type == EffectType::Audio || type == EffectType::CustomAudio;
         if (isAudioEffect) {
             if (state != PlaylistState::AudioOnly) {
                 continue;
             }
         } else if (state != PlaylistState::VideoOnly) {
             continue;
         }
         bool effectEnabled = true;
         if (Xml::hasXmlProperty(node, QLatin1String("disable"))) {
             effectEnabled = Xml::getXmlProperty(node, QLatin1String("disable")).toInt() != 1;
         }
         auto effect = EffectItemModel::construct(effectId, shared_from_this(), effectEnabled);
         const QString in = node.attribute(QStringLiteral("in"));
         const QString out = node.attribute(QStringLiteral("out"));
         if (!out.isEmpty()) {
             effect->filter().set("in", in.toUtf8().constData());
             effect->filter().set("out", out.toUtf8().constData());
         }
         QStringList keyframeParams = effect->getKeyframableParameters();
         QVector<QPair<QString, QVariant>> parameters;
         QDomNodeList params = node.elementsByTagName(QStringLiteral("property"));
         for (int j = 0; j < params.count(); j++) {
             QDomElement pnode = params.item(j).toElement();
             const QString pName = pnode.attribute(QStringLiteral("name"));
             if (pName == QLatin1String("in") || pName == QLatin1String("out")) {
                 continue;
             }
             if (keyframeParams.contains(pName)) {
                 // This is a keyframable parameter, fix offset
                 QString pValue = KeyframeModel::getAnimationStringWithOffset(effect, pnode.text(), currentIn - parentIn);
                 parameters.append(QPair<QString, QVariant>(pName, QVariant(pValue)));
             } else {
                 parameters.append(QPair<QString, QVariant>(pName, QVariant(pnode.text())));
             }
         }
         effect->setParameters(parameters);
         Fun local_undo = removeItem_lambda(effect->getId());
         // TODO the parent should probably not always be the root
         Fun local_redo = addItem_lambda(effect, rootItem->getId());
         effect->prepareKeyframes();
         connect(effect.get(), &AssetParameterModel::modelChanged, this, &EffectStackModel::modelChanged);
         connect(effect.get(), &AssetParameterModel::replugEffect, this, &EffectStackModel::replugEffect, Qt::DirectConnection);
         if (effectId == QLatin1String("fadein") || effectId == QLatin1String("fade_from_black")) {
             m_fadeIns.insert(effect->getId());
             int duration = effect->filter().get_length() - 1;
             effect->filter().set("in", currentIn);
             effect->filter().set("out", currentIn + duration);
         } else if (effectId == QLatin1String("fadeout") || effectId == QLatin1String("fade_to_black")) {
             m_fadeOuts.insert(effect->getId());
             int duration = effect->filter().get_length() - 1;
             int filterOut = pCore->getItemIn(m_ownerId) + pCore->getItemDuration(m_ownerId) - 1;
             effect->filter().set("in", filterOut - duration);
             effect->filter().set("out", filterOut);
         }
         local_redo();
         UPDATE_UNDO_REDO(local_redo, local_undo, undo, redo);
     }
     if (true) {
         Fun update = [this]() {
             emit dataChanged(QModelIndex(), QModelIndex(), {});
             return true;
         };
         update();
         PUSH_LAMBDA(update, redo);
         PUSH_LAMBDA(update, undo);
     }
     return true;
 }
 
 bool EffectStackModel::copyEffect(const std::shared_ptr<AbstractEffectItem> &sourceItem, PlaylistState::ClipState state)
 {
     QWriteLocker locker(&m_lock);
     if (sourceItem->childCount() > 0) {
         // TODO: group
         return false;
     }
     bool audioEffect = sourceItem->isAudio();
     if (audioEffect) {
         if (state == PlaylistState::VideoOnly) {
             // This effect cannot be used
             return false;
         }
     } else if (state == PlaylistState::AudioOnly) {
         return false;
     }
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(sourceItem);
     const QString effectId = sourceEffect->getAssetId();
     bool enabled = sourceEffect->isEnabled();
     auto effect = EffectItemModel::construct(effectId, shared_from_this(), enabled);
     effect->setParameters(sourceEffect->getAllParameters());
     if (!enabled) {
         effect->filter().set("disable", 1);
     }
     effect->filter().set("in", sourceEffect->filter().get_int("in"));
     effect->filter().set("out", sourceEffect->filter().get_int("out"));
     Fun local_undo = removeItem_lambda(effect->getId());
     // TODO the parent should probably not always be the root
     Fun local_redo = addItem_lambda(effect, rootItem->getId());
     effect->prepareKeyframes();
     connect(effect.get(), &AssetParameterModel::modelChanged, this, &EffectStackModel::modelChanged);
     connect(effect.get(), &AssetParameterModel::replugEffect, this, &EffectStackModel::replugEffect, Qt::DirectConnection);
     QVector<int> roles = {TimelineModel::EffectNamesRole};
     if (effectId == QLatin1String("fadein") || effectId == QLatin1String("fade_from_black")) {
         m_fadeIns.insert(effect->getId());
         int duration = effect->filter().get_length() - 1;
         int in = pCore->getItemIn(m_ownerId);
         effect->filter().set("in", in);
         effect->filter().set("out", in + duration);
         roles << TimelineModel::FadeInRole;
     } else if (effectId == QLatin1String("fadeout") || effectId == QLatin1String("fade_to_black")) {
         m_fadeOuts.insert(effect->getId());
         int duration = effect->filter().get_length() - 1;
         int out = pCore->getItemIn(m_ownerId) + pCore->getItemDuration(m_ownerId) - 1;
         effect->filter().set("in", out - duration);
         effect->filter().set("out", out);
         roles << TimelineModel::FadeOutRole;
     }
     bool res = local_redo();
     if (res) {
         Fun update = [this, roles]() {
             emit dataChanged(QModelIndex(), QModelIndex(), roles);
             return true;
         };
     }
     return res;
 }
 
 bool EffectStackModel::appendEffect(const QString &effectId, bool makeCurrent)
 {
     QWriteLocker locker(&m_lock);
     auto effect = EffectItemModel::construct(effectId, shared_from_this());
     PlaylistState::ClipState state = pCore->getItemState(m_ownerId);
     if (effect->isAudio()) {
         if (state == PlaylistState::VideoOnly) {
             // Cannot add effect to this clip
             return false;
         }
     } else if (state == PlaylistState::AudioOnly) {
         // Cannot add effect to this clip
         return false;
     }
     Fun undo = removeItem_lambda(effect->getId());
     // TODO the parent should probably not always be the root
     Fun redo = addItem_lambda(effect, rootItem->getId());
     effect->prepareKeyframes();
     connect(effect.get(), &AssetParameterModel::modelChanged, this, &EffectStackModel::modelChanged);
     connect(effect.get(), &AssetParameterModel::replugEffect, this, &EffectStackModel::replugEffect, Qt::DirectConnection);
     int currentActive = getActiveEffect();
     if (makeCurrent) {
         if (auto srvPtr = m_masterService.lock()) {
             srvPtr->set("kdenlive:activeeffect", rowCount());
         }
     }
     bool res = redo();
     if (res) {
         int inFades = 0;
         int outFades = 0;
 
         if (effectId == QLatin1String("fadein") || effectId == QLatin1String("fade_from_black")) {
             int duration = effect->filter().get_length() - 1;
             int in = pCore->getItemIn(m_ownerId);
             effect->filter().set("in", in);
             effect->filter().set("out", in + duration);
             inFades++;
         } else if (effectId == QLatin1String("fadeout") || effectId == QLatin1String("fade_to_black")) {
             /*int duration = effect->filter().get_length() - 1;
             int out = pCore->getItemIn(m_ownerId) + pCore->getItemDuration(m_ownerId) - 1;
             effect->filter().set("in", out - duration);
             effect->filter().set("out", out);*/
             outFades++;
         } else if (m_ownerId.first == ObjectType::TimelineTrack) {
             effect->filter().set("out", pCore->getItemDuration(m_ownerId));
         }
         QString effectName = EffectsRepository::get()->getName(effectId);
         Fun update = [this, inFades, outFades]() {
             // TODO: only update if effect is fade or keyframe
             QVector<int> roles = {TimelineModel::EffectNamesRole};
             if (inFades > 0) {
                 roles << TimelineModel::FadeInRole;
             } else if (outFades > 0) {
                 roles << TimelineModel::FadeOutRole;
             }
             pCore->updateItemKeyframes(m_ownerId);
             emit dataChanged(QModelIndex(), QModelIndex(), roles);
             return true;
         };
         update();
         PUSH_LAMBDA(update, redo);
         PUSH_LAMBDA(update, undo);
         PUSH_UNDO(undo, redo, i18n("Add effect %1", i18n(effectName.toUtf8().data())));
     } else if (makeCurrent) {
         if (auto srvPtr = m_masterService.lock()) {
             srvPtr->set("kdenlive:activeeffect", currentActive);
         }
     }
     return res;
 }
 
 bool EffectStackModel::adjustStackLength(bool adjustFromEnd, int oldIn, int oldDuration, int newIn, int duration, int offset, Fun &undo, Fun &redo,
                                          bool logUndo)
 {
     QWriteLocker locker(&m_lock);
     const int fadeInDuration = getFadePosition(true);
     const int fadeOutDuration = getFadePosition(false);
     int out = newIn + duration;
     for (const auto &leaf : rootItem->getLeaves()) {
         std::shared_ptr<AbstractEffectItem> item = std::static_pointer_cast<AbstractEffectItem>(leaf);
         if (item->effectItemType() == EffectItemType::Group) {
             // probably an empty group, ignore
             continue;
         }
         std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(leaf);
         if (fadeInDuration > 0 && m_fadeIns.count(leaf->getId()) > 0) {
             int oldEffectIn = qMax(0, effect->filter().get_in());
             int oldEffectOut = effect->filter().get_out();
             qDebug() << "--previous effect: " << oldEffectIn << "-" << oldEffectOut;
             int effectDuration = qMin(effect->filter().get_length() - 1, duration);
             if (!adjustFromEnd && (oldIn != newIn || duration != oldDuration)) {
                 // Clip start was resized, adjust effect in / out
                 Fun operation = [effect, newIn, effectDuration, logUndo]() {
                     effect->setParameter(QStringLiteral("in"), newIn, false);
                     effect->setParameter(QStringLiteral("out"), newIn + effectDuration, logUndo);
                     qDebug() << "--new effect: " << newIn << "-" << newIn + effectDuration;
                     return true;
                 };
                 bool res = operation();
                 if (!res) {
                     return false;
                 }
                 Fun reverse = [effect, oldEffectIn, oldEffectOut, logUndo]() {
                     effect->setParameter(QStringLiteral("in"), oldEffectIn, false);
                     effect->setParameter(QStringLiteral("out"), oldEffectOut, logUndo);
                     return true;
                 };
                 PUSH_LAMBDA(operation, redo);
                 PUSH_LAMBDA(reverse, undo);
             } else if (effectDuration < oldEffectOut - oldEffectIn || (logUndo && effect->filter().get_int("_refout") > 0)) {
                 // Clip length changed, shorter than effect length so resize
                 int referenceEffectOut = effect->filter().get_int("_refout");
                 if (referenceEffectOut <= 0) {
                     referenceEffectOut = oldEffectOut;
                     effect->filter().set("_refout", referenceEffectOut);
                 }
                 Fun operation = [effect, oldEffectIn, effectDuration, logUndo]() {
                     effect->setParameter(QStringLiteral("out"), oldEffectIn + effectDuration, logUndo);
                     return true;
                 };
                 bool res = operation();
                 if (!res) {
                     return false;
                 }
                 if (logUndo) {
                     Fun reverse = [effect, referenceEffectOut]() {
                         effect->setParameter(QStringLiteral("out"), referenceEffectOut, true);
                         effect->filter().set("_refout", (char *)nullptr);
                         return true;
                     };
                     PUSH_LAMBDA(operation, redo);
                     PUSH_LAMBDA(reverse, undo);
                 }
             }
         } else if (fadeOutDuration > 0 && m_fadeOuts.count(leaf->getId()) > 0) {
             int effectDuration = qMin(fadeOutDuration, duration);
             int newFadeIn = out - effectDuration;
             int oldFadeIn = effect->filter().get_int("in");
             int oldOut = effect->filter().get_int("out");
             int referenceEffectIn = effect->filter().get_int("_refin");
             if (referenceEffectIn <= 0) {
                 referenceEffectIn = oldFadeIn;
                 effect->filter().set("_refin", referenceEffectIn);
             }
             Fun operation = [effect, newFadeIn, out, logUndo]() {
                 effect->setParameter(QStringLiteral("in"), newFadeIn, false);
                 effect->setParameter(QStringLiteral("out"), out, logUndo);
                 return true;
             };
             bool res = operation();
             if (!res) {
                 return false;
             }
             if (logUndo) {
                 Fun reverse = [effect, referenceEffectIn, oldOut]() {
                     effect->setParameter(QStringLiteral("in"), referenceEffectIn, false);
                     effect->setParameter(QStringLiteral("out"), oldOut, true);
                     effect->filter().set("_refin", (char *)nullptr);
                     return true;
                 };
                 PUSH_LAMBDA(operation, redo);
                 PUSH_LAMBDA(reverse, undo);
             }
         } else {
             // Not a fade effect, check for keyframes
             std::shared_ptr<KeyframeModelList> keyframes = effect->getKeyframeModel();
             if (keyframes != nullptr) {
                 // Effect has keyframes, update these
                 keyframes->resizeKeyframes(oldIn, oldIn + oldDuration - 1, newIn, out - 1, offset, adjustFromEnd, undo, redo);
                 QModelIndex index = getIndexFromItem(effect);
                 Fun refresh = [effect, index]() {
                     effect->dataChanged(index, index, QVector<int>());
                     return true;
                 };
                 refresh();
                 PUSH_LAMBDA(refresh, redo);
                 PUSH_LAMBDA(refresh, undo);
             } else {
-                qDebug() << "// NULL Keyframes---------";
+                if (m_ownerId.first == ObjectType::TimelineTrack) {
+                    int oldEffectOut = effect->filter().get_out();
+                    Fun operation = [effect, out, logUndo]() {
+                        effect->setParameter(QStringLiteral("out"), out, logUndo);
+                        return true;
+                    };
+                    bool res = operation();
+                    if (!res) {
+                        return false;
+                    }
+                    if (logUndo) {
+                        Fun reverse = [effect, oldEffectOut]() {
+                            effect->setParameter(QStringLiteral("out"), oldEffectOut, true);
+                            return true;
+                        };
+                        PUSH_LAMBDA(operation, redo);
+                        PUSH_LAMBDA(reverse, undo);
+                    }
+                } else {
+                    qDebug() << "// NULL Keyframes---------";
+                }
             }
         }
     }
     return true;
 }
 
 bool EffectStackModel::adjustFadeLength(int duration, bool fromStart, bool audioFade, bool videoFade, bool logUndo)
 {
     QWriteLocker locker(&m_lock);
     if (fromStart) {
         // Fade in
         if (m_fadeIns.empty()) {
             if (audioFade) {
                 appendEffect(QStringLiteral("fadein"));
             }
             if (videoFade) {
                 appendEffect(QStringLiteral("fade_from_black"));
             }
         }
         QList<QModelIndex> indexes;
         auto ptr = m_masterService.lock();
         int in = 0;
         if (ptr) {
             in = ptr->get_int("in");
         }
         int oldDuration = -1;
         for (int i = 0; i < rootItem->childCount(); ++i) {
             if (m_fadeIns.count(std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) > 0) {
                 std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
                 if (oldDuration == -1) {
                     oldDuration = effect->filter().get_length();
                 }
                 effect->filter().set("in", in);
                 duration = qMin(pCore->getItemDuration(m_ownerId), duration);
                 effect->filter().set("out", in + duration);
                 indexes << getIndexFromItem(effect);
             }
         }
         if (!indexes.isEmpty()) {
             emit dataChanged(indexes.first(), indexes.last(), QVector<int>());
             pCore->updateItemModel(m_ownerId, QStringLiteral("fadein"));
             if (videoFade) {
                 int min = pCore->getItemPosition(m_ownerId);
                 QSize range(min, min + qMax(duration, oldDuration));
                 pCore->refreshProjectRange(range);
                 if (logUndo) {
                     pCore->invalidateRange(range);
                 }
             }
         }
     } else {
         // Fade out
         if (m_fadeOuts.empty()) {
             if (audioFade) {
                 appendEffect(QStringLiteral("fadeout"));
             }
             if (videoFade) {
                 appendEffect(QStringLiteral("fade_to_black"));
             }
         }
         int in = 0;
         auto ptr = m_masterService.lock();
         if (ptr) {
             in = ptr->get_int("in");
         }
         int itemDuration = pCore->getItemDuration(m_ownerId);
         int out = in + itemDuration;
         int oldDuration = -1;
         QList<QModelIndex> indexes;
         for (int i = 0; i < rootItem->childCount(); ++i) {
             if (m_fadeOuts.count(std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) > 0) {
                 std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
                 if (oldDuration == -1) {
                     oldDuration = effect->filter().get_length();
                 }
                 effect->filter().set("out", out - 1);
                 duration = qMin(itemDuration, duration);
                 effect->filter().set("in", out - duration);
                 indexes << getIndexFromItem(effect);
             }
         }
         if (!indexes.isEmpty()) {
             emit dataChanged(indexes.first(), indexes.last(), QVector<int>());
             pCore->updateItemModel(m_ownerId, QStringLiteral("fadeout"));
             if (videoFade) {
                 int min = pCore->getItemPosition(m_ownerId);
                 QSize range(min + itemDuration - qMax(duration, oldDuration), min + itemDuration);
                 pCore->refreshProjectRange(range);
                 if (logUndo) {
                     pCore->invalidateRange(range);
                 }
             }
         }
     }
     return true;
 }
 
 int EffectStackModel::getFadePosition(bool fromStart)
 {
     QWriteLocker locker(&m_lock);
     if (fromStart) {
         if (m_fadeIns.empty()) {
             return 0;
         }
         for (int i = 0; i < rootItem->childCount(); ++i) {
             if (*(m_fadeIns.begin()) == std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) {
                 std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
                 return effect->filter().get_length() - 1;
             }
         }
     } else {
         if (m_fadeOuts.empty()) {
             return 0;
         }
         for (int i = 0; i < rootItem->childCount(); ++i) {
             if (*(m_fadeOuts.begin()) == std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) {
                 std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
                 return effect->filter().get_length() - 1;
             }
         }
     }
     return 0;
 }
 
 bool EffectStackModel::removeFade(bool fromStart)
 {
     QWriteLocker locker(&m_lock);
     std::vector<int> toRemove;
     for (int i = 0; i < rootItem->childCount(); ++i) {
         if ((fromStart && m_fadeIns.count(std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) > 0) ||
             (!fromStart && m_fadeOuts.count(std::static_pointer_cast<TreeItem>(rootItem->child(i))->getId()) > 0)) {
             toRemove.push_back(i);
         }
     }
     for (int i : toRemove) {
         std::shared_ptr<EffectItemModel> effect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
         removeEffect(effect);
     }
     return true;
 }
 
 void EffectStackModel::moveEffect(int destRow, const std::shared_ptr<AbstractEffectItem> &item)
 {
     QWriteLocker locker(&m_lock);
     Q_ASSERT(m_allItems.count(item->getId()) > 0);
     int oldRow = item->row();
     Fun undo = moveItem_lambda(item->getId(), oldRow);
     Fun redo = moveItem_lambda(item->getId(), destRow);
     bool res = redo();
     if (res) {
         Fun update = [this]() {
             this->dataChanged(QModelIndex(), QModelIndex(), {TimelineModel::EffectNamesRole});
             return true;
         };
         update();
         UPDATE_UNDO_REDO(update, update, undo, redo);
         auto effectId = std::static_pointer_cast<EffectItemModel>(item)->getAssetId();
         QString effectName = EffectsRepository::get()->getName(effectId);
         PUSH_UNDO(undo, redo, i18n("Move effect %1").arg(i18n(effectName.toUtf8().data())));
     }
 }
 
 void EffectStackModel::registerItem(const std::shared_ptr<TreeItem> &item)
 {
     QWriteLocker locker(&m_lock);
     // qDebug() << "$$$$$$$$$$$$$$$$$$$$$ Planting effect";
     QModelIndex ix;
     if (!item->isRoot()) {
         auto effectItem = std::static_pointer_cast<EffectItemModel>(item);
         if (!m_loadingExisting) {
             // qDebug() << "$$$$$$$$$$$$$$$$$$$$$ Planting effect in " << m_childServices.size();
             effectItem->plant(m_masterService);
             for (const auto &service : m_childServices) {
                 // qDebug() << "$$$$$$$$$$$$$$$$$$$$$ Planting CLONE effect in " << (void *)service.lock().get();
                 effectItem->plantClone(service);
             }
         }
         effectItem->setEffectStackEnabled(m_effectStackEnabled);
         const QString &effectId = effectItem->getAssetId();
         if (effectId == QLatin1String("fadein") || effectId == QLatin1String("fade_from_black")) {
             m_fadeIns.insert(effectItem->getId());
         } else if (effectId == QLatin1String("fadeout") || effectId == QLatin1String("fade_to_black")) {
             m_fadeOuts.insert(effectItem->getId());
         }
         ix = getIndexFromItem(effectItem);
         if (!effectItem->isAudio() && !m_loadingExisting) {
             pCore->refreshProjectItem(m_ownerId);
             pCore->invalidateItem(m_ownerId);
         }
     }
     AbstractTreeModel::registerItem(item);
 }
 
 void EffectStackModel::deregisterItem(int id, TreeItem *item)
 {
     QWriteLocker locker(&m_lock);
     if (!item->isRoot()) {
         auto effectItem = static_cast<AbstractEffectItem *>(item);
         effectItem->unplant(m_masterService);
         for (const auto &service : m_childServices) {
             effectItem->unplantClone(service);
         }
         if (!effectItem->isAudio()) {
             pCore->refreshProjectItem(m_ownerId);
             pCore->invalidateItem(m_ownerId);
         }
     }
     AbstractTreeModel::deregisterItem(id, item);
 }
 
 void EffectStackModel::setEffectStackEnabled(bool enabled)
 {
     QWriteLocker locker(&m_lock);
     m_effectStackEnabled = enabled;
 
     // Recursively updates children states
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::static_pointer_cast<AbstractEffectItem>(rootItem->child(i))->setEffectStackEnabled(enabled);
     }
     emit dataChanged(QModelIndex(), QModelIndex(), {TimelineModel::EffectsEnabledRole});
     emit enabledStateChanged();
 }
 
 std::shared_ptr<AbstractEffectItem> EffectStackModel::getEffectStackRow(int row, const std::shared_ptr<TreeItem> &parentItem)
 {
     return std::static_pointer_cast<AbstractEffectItem>(parentItem ? parentItem->child(row) : rootItem->child(row));
 }
 
 bool EffectStackModel::importEffects(const std::shared_ptr<EffectStackModel> &sourceStack, PlaylistState::ClipState state)
 {
     QWriteLocker locker(&m_lock);
     // TODO: manage fades, keyframes if clips don't have same size / in point
     bool found = false;
     for (int i = 0; i < sourceStack->rowCount(); i++) {
         auto item = sourceStack->getEffectStackRow(i);
         // NO undo. this should only be used on project opening
         if (copyEffect(item, state)) {
             found = true;
         }
     }
     if (found) {
         modelChanged();
     }
     return found;
 }
 
 void EffectStackModel::importEffects(const std::weak_ptr<Mlt::Service> &service, PlaylistState::ClipState state, bool alreadyExist)
 {
     QWriteLocker locker(&m_lock);
     m_loadingExisting = alreadyExist;
     if (auto ptr = service.lock()) {
         for (int i = 0; i < ptr->filter_count(); i++) {
             std::unique_ptr<Mlt::Service> filter(ptr->filter(i));
             if (filter->get("kdenlive_id") == nullptr) {
                 // don't consider internal MLT stuff
                 continue;
             }
             const QString effectId = qstrdup(filter->get("kdenlive_id"));
             // The MLT filter already exists, use it directly to create the effect
             std::shared_ptr<EffectItemModel> effect;
             if (alreadyExist) {
                 // effect is already plugged in the service
                 effect = EffectItemModel::construct(std::move(filter), shared_from_this());
             } else {
                 // duplicate effect
                 std::unique_ptr<Mlt::Filter> asset = EffectsRepository::get()->getEffect(effectId);
                 asset->inherit(*(filter));
                 effect = EffectItemModel::construct(std::move(asset), shared_from_this());
             }
             if (effect->isAudio()) {
                 if (state == PlaylistState::VideoOnly) {
                     // Don't import effect
                     continue;
                 }
             } else if (state == PlaylistState::AudioOnly) {
                 // Don't import effect
                 continue;
             }
             connect(effect.get(), &AssetParameterModel::modelChanged, this, &EffectStackModel::modelChanged);
             connect(effect.get(), &AssetParameterModel::replugEffect, this, &EffectStackModel::replugEffect, Qt::DirectConnection);
             Fun redo = addItem_lambda(effect, rootItem->getId());
             effect->prepareKeyframes();
             if (redo()) {
                 if (effectId == QLatin1String("fadein") || effectId == QLatin1String("fade_from_black")) {
                     m_fadeIns.insert(effect->getId());
                     int clipIn = ptr->get_int("in");
                     if (effect->filter().get_int("in") != clipIn) {
                         // Broken fade, fix
                         int filterLength = effect->filter().get_length() - 1;
                         effect->filter().set("in", clipIn);
                         effect->filter().set("out", clipIn + filterLength);
                     }
                 } else if (effectId == QLatin1String("fadeout") || effectId == QLatin1String("fade_to_black")) {
                     m_fadeOuts.insert(effect->getId());
                     int clipOut = ptr->get_int("out");
                     if (effect->filter().get_int("out") != clipOut) {
                         // Broken fade, fix
                         int filterLength = effect->filter().get_length() - 1;
                         effect->filter().set("in", clipOut - filterLength);
                         effect->filter().set("out", clipOut);
                     }
                 }
             }
         }
     }
     m_loadingExisting = false;
     modelChanged();
 }
 
 void EffectStackModel::setActiveEffect(int ix)
 {
     QWriteLocker locker(&m_lock);
     if (auto ptr = m_masterService.lock()) {
         ptr->set("kdenlive:activeeffect", ix);
     }
     pCore->updateItemKeyframes(m_ownerId);
 }
 
 int EffectStackModel::getActiveEffect() const
 {
     QWriteLocker locker(&m_lock);
     if (auto ptr = m_masterService.lock()) {
         return ptr->get_int("kdenlive:activeeffect");
     }
     return 0;
 }
 
 void EffectStackModel::slotCreateGroup(const std::shared_ptr<EffectItemModel> &childEffect)
 {
     QWriteLocker locker(&m_lock);
     auto groupItem = EffectGroupModel::construct(QStringLiteral("group"), shared_from_this());
     rootItem->appendChild(groupItem);
     groupItem->appendChild(childEffect);
 }
 
 ObjectId EffectStackModel::getOwnerId() const
 {
     return m_ownerId;
 }
 
 bool EffectStackModel::checkConsistency()
 {
     if (!AbstractTreeModel::checkConsistency()) {
         return false;
     }
 
     std::vector<std::shared_ptr<EffectItemModel>> allFilters;
     // We do a DFS on the tree to retrieve all the filters
     std::stack<std::shared_ptr<AbstractEffectItem>> stck;
     stck.push(std::static_pointer_cast<AbstractEffectItem>(rootItem));
 
     while (!stck.empty()) {
         auto current = stck.top();
         stck.pop();
 
         if (current->effectItemType() == EffectItemType::Effect) {
             if (current->childCount() > 0) {
                 qDebug() << "ERROR: Found an effect with children";
                 return false;
             }
             allFilters.push_back(std::static_pointer_cast<EffectItemModel>(current));
             continue;
         }
         for (int i = current->childCount() - 1; i >= 0; --i) {
             stck.push(std::static_pointer_cast<AbstractEffectItem>(current->child(i)));
         }
     }
 
     for (const auto &service : m_childServices) {
         auto ptr = service.lock();
         if (!ptr) {
             qDebug() << "ERROR: unavailable service";
             return false;
         }
         // MLT inserts some default normalizer filters that are not managed by Kdenlive, which explains  why the filter count is not equal
         int kdenliveFilterCount = 0;
         for (int i = 0; i < ptr->filter_count(); i++) {
             std::shared_ptr<Mlt::Filter> filt(ptr->filter(i));
             if (filt->get("kdenlive_id") != nullptr) {
                 kdenliveFilterCount++;
             }
             // qDebug() << "FILTER: "<<i<<" : "<<ptr->filter(i)->get("mlt_service");
         }
         if (kdenliveFilterCount != (int)allFilters.size()) {
             qDebug() << "ERROR: Wrong filter count: " << kdenliveFilterCount << " = " << allFilters.size();
             return false;
         }
 
         int ct = 0;
         for (uint i = 0; i < allFilters.size(); ++i) {
             while (ptr->filter(ct)->get("kdenlive_id") == nullptr && ct < ptr->filter_count()) {
                 ct++;
             }
             auto mltFilter = ptr->filter(ct);
             auto currentFilter = allFilters[i]->filter();
             if (QString(currentFilter.get("mlt_service")) != QLatin1String(mltFilter->get("mlt_service"))) {
                 qDebug() << "ERROR: filter " << i << "differ: " << ct << ", " << currentFilter.get("mlt_service") << " = " << mltFilter->get("mlt_service");
                 return false;
             }
             QVector<QPair<QString, QVariant>> params = allFilters[i]->getAllParameters();
             for (const auto &val : params) {
                 // Check parameters values
                 if (val.second != QVariant(mltFilter->get(val.first.toUtf8().constData()))) {
                     qDebug() << "ERROR: filter " << i << "PARAMETER MISMATCH: " << val.first << " = " << val.second
                              << " != " << mltFilter->get(val.first.toUtf8().constData());
                     return false;
                 }
             }
             ct++;
         }
     }
 
     return true;
 }
 
 void EffectStackModel::adjust(const QString &effectId, const QString &effectName, double value)
 {
     QWriteLocker locker(&m_lock);
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
         if (effectId == sourceEffect->getAssetId()) {
             sourceEffect->setParameter(effectName, QString::number(value));
             return;
         }
     }
 }
 
 std::shared_ptr<AssetParameterModel> EffectStackModel::getAssetModelById(const QString &effectId)
 {
     QWriteLocker locker(&m_lock);
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
         if (effectId == sourceEffect->getAssetId()) {
             return std::static_pointer_cast<AssetParameterModel>(sourceEffect);
         }
     }
     return nullptr;
 }
 
 
 bool EffectStackModel::hasFilter(const QString &effectId) const
 {
     READ_LOCK();
     return rootItem->accumulate_const(false, [effectId](bool b, std::shared_ptr<const TreeItem> it) {
         if (b) return true;
         auto item = std::static_pointer_cast<const AbstractEffectItem>(it);
         if (item->effectItemType() == EffectItemType::Group) {
             return false;
         }
         auto sourceEffect = std::static_pointer_cast<const EffectItemModel>(it);
         return effectId == sourceEffect->getAssetId();
     });
 }
 
 double EffectStackModel::getFilterParam(const QString &effectId, const QString &paramName)
 {
     READ_LOCK();
     for (int i = 0; i < rootItem->childCount(); ++i) {
         std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(i));
         if (effectId == sourceEffect->getAssetId()) {
             return sourceEffect->filter().get_double(paramName.toUtf8().constData());
         }
     }
     return 0.0;
 }
 
 KeyframeModel *EffectStackModel::getEffectKeyframeModel()
 {
     if (rootItem->childCount() == 0) return nullptr;
     int ix = 0;
     if (auto ptr = m_masterService.lock()) {
         ix = ptr->get_int("kdenlive:activeeffect");
     }
     if (ix < 0 || ix >= rootItem->childCount()) {
         return nullptr;
     }
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
     std::shared_ptr<KeyframeModelList> listModel = sourceEffect->getKeyframeModel();
     if (listModel) {
         return listModel->getKeyModel();
     }
     return nullptr;
 }
 
 void EffectStackModel::replugEffect(const std::shared_ptr<AssetParameterModel> &asset)
 {
     QWriteLocker locker(&m_lock);
     auto effectItem = std::static_pointer_cast<EffectItemModel>(asset);
     int oldRow = effectItem->row();
     int count = rowCount();
     for (int ix = oldRow; ix < count; ix++) {
         auto item = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
         item->unplant(m_masterService);
         for (const auto &service : m_childServices) {
             item->unplantClone(service);
         }
     }
     std::unique_ptr<Mlt::Properties> effect = EffectsRepository::get()->getEffect(effectItem->getAssetId());
     effect->inherit(effectItem->filter());
     effectItem->resetAsset(std::move(effect));
     for (int ix = oldRow; ix < count; ix++) {
         auto item = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
         item->plant(m_masterService);
         for (const auto &service : m_childServices) {
             item->plantClone(service);
         }
     }
 }
 
 void EffectStackModel::cleanFadeEffects(bool outEffects, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     const auto &toDelete = outEffects ? m_fadeOuts : m_fadeIns;
     for (int id : toDelete) {
         auto effect = std::static_pointer_cast<EffectItemModel>(getItemById(id));
         Fun operation = removeItem_lambda(id);
         if (operation()) {
             Fun reverse = addItem_lambda(effect, rootItem->getId());
             UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         }
     }
     if (!toDelete.empty()) {
         Fun updateRedo = [this, toDelete, outEffects]() {
             for (int id : toDelete) {
                 if (outEffects) {
                     m_fadeOuts.erase(id);
                 } else {
                     m_fadeIns.erase(id);
                 }
             }
             QVector<int> roles = {TimelineModel::EffectNamesRole};
             roles << (outEffects ? TimelineModel::FadeOutRole : TimelineModel::FadeInRole);
             emit dataChanged(QModelIndex(), QModelIndex(), roles);
             pCore->updateItemKeyframes(m_ownerId);
             return true;
         };
         updateRedo();
         PUSH_LAMBDA(updateRedo, redo);
     }
 }
 
 const QString EffectStackModel::effectNames() const
 {
     QStringList effects;
     for (int i = 0; i < rootItem->childCount(); ++i) {
         effects.append(i18n(EffectsRepository::get()->getName(std::static_pointer_cast<EffectItemModel>(rootItem->child(i))->getAssetId()).toUtf8().data()));
     }
     return effects.join(QLatin1Char('/'));
 }
 
 bool EffectStackModel::isStackEnabled() const
 {
     return m_effectStackEnabled;
 }
 
 bool EffectStackModel::addEffectKeyFrame(int frame, double normalisedVal)
 {
     if (rootItem->childCount() == 0) return false;
     int ix = 0;
     if (auto ptr = m_masterService.lock()) {
         ix = ptr->get_int("kdenlive:activeeffect");
     }
     if (ix < 0) {
         return false;
     }
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
     std::shared_ptr<KeyframeModelList> listModel = sourceEffect->getKeyframeModel();
     if (m_ownerId.first == ObjectType::TimelineTrack) {
         sourceEffect->filter().set("out", pCore->getItemDuration(m_ownerId));
     }
     return listModel->addKeyframe(frame, normalisedVal);
 }
 
 bool EffectStackModel::removeKeyFrame(int frame)
 {
     if (rootItem->childCount() == 0) return false;
     int ix = 0;
     if (auto ptr = m_masterService.lock()) {
         ix = ptr->get_int("kdenlive:activeeffect");
     }
     if (ix < 0) {
         return false;
     }
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
     std::shared_ptr<KeyframeModelList> listModel = sourceEffect->getKeyframeModel();
     return listModel->removeKeyframe(GenTime(frame, pCore->getCurrentFps()));
 }
 
 bool EffectStackModel::updateKeyFrame(int oldFrame, int newFrame, QVariant normalisedVal)
 {
     if (rootItem->childCount() == 0) return false;
     int ix = 0;
     if (auto ptr = m_masterService.lock()) {
         ix = ptr->get_int("kdenlive:activeeffect");
     }
     if (ix < 0) {
         return false;
     }
     std::shared_ptr<EffectItemModel> sourceEffect = std::static_pointer_cast<EffectItemModel>(rootItem->child(ix));
     std::shared_ptr<KeyframeModelList> listModel = sourceEffect->getKeyframeModel();
     if (m_ownerId.first == ObjectType::TimelineTrack) {
         sourceEffect->filter().set("out", pCore->getItemDuration(m_ownerId));
     }
     return listModel->updateKeyframe(GenTime(oldFrame, pCore->getCurrentFps()), GenTime(newFrame, pCore->getCurrentFps()), std::move(normalisedVal));
 }
diff --git a/src/timeline2/model/clipmodel.cpp b/src/timeline2/model/clipmodel.cpp
index a026405ef..84d996ed4 100644
--- a/src/timeline2/model/clipmodel.cpp
+++ b/src/timeline2/model/clipmodel.cpp
@@ -1,830 +1,842 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Nicolas Carion                                  *
  *   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 "clipmodel.hpp"
 #include "bin/projectclip.h"
 #include "bin/projectitemmodel.h"
 #include "clipsnapmodel.hpp"
 #include "core.h"
 #include "effects/effectstack/model/effectstackmodel.hpp"
 #include "logger.hpp"
 #include "macros.hpp"
 #include "timelinemodel.hpp"
 #include "trackmodel.hpp"
 #include <QDebug>
 #include <effects/effectsrepository.hpp>
 #include <mlt++/MltProducer.h>
 #include <utility>
 
 ClipModel::ClipModel(const std::shared_ptr<TimelineModel> &parent, std::shared_ptr<Mlt::Producer> prod, const QString &binClipId, int id,
                      PlaylistState::ClipState state, double speed)
     : MoveableItem<Mlt::Producer>(parent, id)
     , m_producer(std::move(prod))
     , m_effectStack(EffectStackModel::construct(m_producer, {ObjectType::TimelineClip, m_id}, parent->m_undoStack))
     , m_clipMarkerModel(new ClipSnapModel())
     , m_binClipId(binClipId)
     , forceThumbReload(false)
     , m_currentState(state)
     , m_speed(speed)
     , m_fakeTrack(-1)
     , m_positionOffset(0)
 {
     m_producer->set("kdenlive:id", binClipId.toUtf8().constData());
     m_producer->set("_kdenlive_cid", m_id);
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     m_canBeVideo = binClip->hasVideo();
     m_canBeAudio = binClip->hasAudio();
     m_clipType = binClip->clipType();
     if (binClip) {
         m_endlessResize = !binClip->hasLimitedDuration();
     } else {
         m_endlessResize = false;
     }
     QObject::connect(m_effectStack.get(), &EffectStackModel::dataChanged, [&](const QModelIndex &, const QModelIndex &, QVector<int> roles) {
         qDebug() << "// GOT CLIP STACK DATA CHANGE: " << roles;
         if (m_currentTrackId != -1) {
             if (auto ptr = m_parent.lock()) {
                 QModelIndex ix = ptr->makeClipIndexFromID(m_id);
                 qDebug() << "// GOT CLIP STACK DATA CHANGE DONE: " << ix << " = " << roles;
                 ptr->dataChanged(ix, ix, roles);
             }
         }
     });
 }
 
 int ClipModel::construct(const std::shared_ptr<TimelineModel> &parent, const QString &binClipId, int id, PlaylistState::ClipState state, double speed)
 {
     id = (id == -1 ? TimelineModel::getNextId() : id);
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(binClipId);
 
     // We refine the state according to what the clip can actually produce
     std::pair<bool, bool> videoAudio = stateToBool(state);
     videoAudio.first = videoAudio.first && binClip->hasVideo();
     videoAudio.second = videoAudio.second && binClip->hasAudio();
     state = stateFromBool(videoAudio);
     std::shared_ptr<Mlt::Producer> cutProducer = binClip->getTimelineProducer(-1, id, state, speed);
     std::shared_ptr<ClipModel> clip(new ClipModel(parent, cutProducer, binClipId, id, state, speed));
     TRACE_CONSTR(clip.get(), parent, binClipId, id, state, speed);
     clip->setClipState_lambda(state)();
     parent->registerClip(clip);
     clip->m_clipMarkerModel->setReferenceModel(binClip->getMarkerModel(), speed);
     return id;
 }
 
 int ClipModel::construct(const std::shared_ptr<TimelineModel> &parent, const QString &binClipId, const std::shared_ptr<Mlt::Producer> &producer,
                          PlaylistState::ClipState state)
 {
 
     // we hand the producer to the bin clip, and in return we get a cut to a good master producer
     // We might not be able to use directly the producer that we receive as an argument, because it cannot share the same master producer with any other
     // clipModel (due to a mlt limitation, see ProjectClip doc)
 
     int id = TimelineModel::getNextId();
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(binClipId);
 
     // We refine the state according to what the clip can actually produce
     std::pair<bool, bool> videoAudio = stateToBool(state);
     videoAudio.first = videoAudio.first && binClip->hasVideo();
     videoAudio.second = videoAudio.second && binClip->hasAudio();
     state = stateFromBool(videoAudio);
 
     double speed = 1.0;
     if (QString::fromUtf8(producer->parent().get("mlt_service")) == QLatin1String("timewarp")) {
         speed = producer->parent().get_double("warp_speed");
     }
     auto result = binClip->giveMasterAndGetTimelineProducer(id, producer, state);
     std::shared_ptr<ClipModel> clip(new ClipModel(parent, result.first, binClipId, id, state, speed));
     clip->setClipState_lambda(state)();
     parent->registerClip(clip);
     clip->m_effectStack->importEffects(producer, state, result.second);
     clip->m_clipMarkerModel->setReferenceModel(binClip->getMarkerModel(), speed);
     return id;
 }
 
 void ClipModel::registerClipToBin(std::shared_ptr<Mlt::Producer> service, bool registerProducer)
 {
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     if (!binClip) {
         qDebug() << "Error : Bin clip for id: " << m_binClipId << " NOT AVAILABLE!!!";
     }
     qDebug() << "REGISTRATION " << m_id << "ptr count" << m_parent.use_count();
     binClip->registerService(m_parent, m_id, std::move(service), registerProducer);
 }
 
 void ClipModel::deregisterClipToBin()
 {
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     binClip->deregisterTimelineClip(m_id);
 }
 
 ClipModel::~ClipModel() = default;
 
 bool ClipModel::requestResize(int size, bool right, Fun &undo, Fun &redo, bool logUndo)
 {
     QWriteLocker locker(&m_lock);
     // qDebug() << "RESIZE CLIP" << m_id << "target size=" << size << "right=" << right << "endless=" << m_endlessResize << "length" <<
     // m_producer->get_length();
     if (!m_endlessResize && (size <= 0 || size > m_producer->get_length())) {
         return false;
     }
     int delta = getPlaytime() - size;
     if (delta == 0) {
         return true;
     }
     int in = m_producer->get_in();
     int out = m_producer->get_out();
     int old_in = in, old_out = out;
     // check if there is enough space on the chosen side
     if (!m_endlessResize) {
         if (!right && in + delta < 0) {
             return false;
         }
         if (right && (out - delta >= m_producer->get_length())) {
             return false;
         }
     }
     if (right) {
         out -= delta;
     } else {
         in += delta;
     }
     // qDebug() << "Resize facts delta =" << delta << "old in" << old_in << "old_out" << old_out << "in" << in << "out" << out;
     std::function<bool(void)> track_operation = []() { return true; };
     std::function<bool(void)> track_reverse = []() { return true; };
     int outPoint = out;
     int inPoint = in;
     int offset = 0;
+    int trackDuration = 0;
     if (m_endlessResize) {
         offset = inPoint;
         outPoint = out - in;
         inPoint = 0;
     }
     if (m_currentTrackId != -1) {
         if (auto ptr = m_parent.lock()) {
             if (ptr->getTrackById(m_currentTrackId)->isLocked()) {
                 return false;
             }
+            if (right && ptr->getTrackById_const(m_currentTrackId)->isLastClip(getPosition())) {
+                trackDuration = ptr->getTrackById_const(m_currentTrackId)->trackDuration();
+            }
             track_operation = ptr->getTrackById(m_currentTrackId)->requestClipResize_lambda(m_id, inPoint, outPoint, right);
         } else {
             qDebug() << "Error : Moving clip failed because parent timeline is not available anymore";
             Q_ASSERT(false);
         }
     } else {
         // Ensure producer is long enough
         if (m_endlessResize && outPoint > m_producer->parent().get_length()) {
             m_producer->set("length", outPoint + 1);
         }
     }
     QVector<int> roles{TimelineModel::DurationRole};
     if (!right) {
         roles.push_back(TimelineModel::StartRole);
         roles.push_back(TimelineModel::InPointRole);
     } else {
         roles.push_back(TimelineModel::OutPointRole);
     }
     
     Fun operation = [this, inPoint, outPoint, roles, track_operation]() {
         if (track_operation()) {
             setInOut(inPoint, outPoint);
             if (m_currentTrackId > -1) {
                 if (auto ptr = m_parent.lock()) {
                     QModelIndex ix = ptr->makeClipIndexFromID(m_id);
                     ptr->notifyChange(ix, ix, roles);
                 }
             }
             return true;
         }
         return false;
     };
     if (operation()) {
         Fun reverse = []() { return true; };
         if (logUndo) {
             // Now, we are in the state in which the timeline should be when we try to revert current action. So we can build the reverse action from here
             if (m_currentTrackId != -1) {
                 if (auto ptr = m_parent.lock()) {
+                    if (trackDuration > 0) {
+                        // Operation changed parent track duration, update effect stack
+                        int newDuration = ptr->getTrackById_const(m_currentTrackId)->trackDuration();
+                        if (logUndo || trackDuration != newDuration) {
+                            // A clip move changed the track duration, update track effects
+                            ptr->getTrackById(m_currentTrackId)->m_effectStack->adjustStackLength(true, 0, trackDuration, 0, newDuration, 0, undo, redo, logUndo);
+                        }
+                    }
                     track_reverse = ptr->getTrackById(m_currentTrackId)->requestClipResize_lambda(m_id, old_in, old_out, right);
                 }
             }
             reverse = [this, old_in, old_out, track_reverse, roles]() {
                 if (track_reverse()) {
                     setInOut(old_in, old_out);
                     if (m_currentTrackId > -1) {
                         if (auto ptr = m_parent.lock()) {
                             QModelIndex ix = ptr->makeClipIndexFromID(m_id);
                             ptr->notifyChange(ix, ix, roles);
                         }
                     }
                     return true;
                 }
                 return false;
             };
             qDebug() << "----------\n-----------\n// ADJUSTING EFFECT LENGTH, LOGUNDO " << logUndo << ", " << old_in << "/" << inPoint << ", "
                  << m_producer->get_playtime();
 
             adjustEffectLength(right, old_in, inPoint, old_out - old_in, m_producer->get_playtime(), offset, reverse, operation, logUndo);
         }
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 const QString ClipModel::getProperty(const QString &name) const
 {
     READ_LOCK();
     if (service()->parent().is_valid()) {
         return QString::fromUtf8(service()->parent().get(name.toUtf8().constData()));
     }
     return QString::fromUtf8(service()->get(name.toUtf8().constData()));
 }
 
 int ClipModel::getIntProperty(const QString &name) const
 {
     READ_LOCK();
     if (service()->parent().is_valid()) {
         return service()->parent().get_int(name.toUtf8().constData());
     }
     return service()->get_int(name.toUtf8().constData());
 }
 
 QSize ClipModel::getFrameSize() const
 {
     READ_LOCK();
     if (service()->parent().is_valid()) {
         return QSize(service()->parent().get_int("meta.media.width"), service()->parent().get_int("meta.media.height"));
     }
     return {service()->get_int("meta.media.width"), service()->get_int("meta.media.height")};
 }
 
 double ClipModel::getDoubleProperty(const QString &name) const
 {
     READ_LOCK();
     if (service()->parent().is_valid()) {
         return service()->parent().get_double(name.toUtf8().constData());
     }
     return service()->get_double(name.toUtf8().constData());
 }
 
 Mlt::Producer *ClipModel::service() const
 {
     READ_LOCK();
     return m_producer.get();
 }
 
 std::shared_ptr<Mlt::Producer> ClipModel::getProducer()
 {
     READ_LOCK();
     return m_producer;
 }
 
 int ClipModel::getPlaytime() const
 {
     READ_LOCK();
     return m_producer->get_playtime();
 }
 
 void ClipModel::setTimelineEffectsEnabled(bool enabled)
 {
     QWriteLocker locker(&m_lock);
     m_effectStack->setEffectStackEnabled(enabled);
 }
 
 bool ClipModel::addEffect(const QString &effectId)
 {
     QWriteLocker locker(&m_lock);
     EffectType type = EffectsRepository::get()->getType(effectId);
     if (type == EffectType::Audio || type == EffectType::CustomAudio) {
         if (m_currentState == PlaylistState::VideoOnly) {
             return false;
         }
     } else if (m_currentState == PlaylistState::AudioOnly) {
         return false;
     }
     m_effectStack->appendEffect(effectId);
     return true;
 }
 
 bool ClipModel::copyEffect(const std::shared_ptr<EffectStackModel> &stackModel, int rowId)
 {
     QWriteLocker locker(&m_lock);
     QDomDocument doc;
     m_effectStack->copyXmlEffect(stackModel->rowToXml(rowId, doc));
     return true;
 }
 
 bool ClipModel::importEffects(std::shared_ptr<EffectStackModel> stackModel)
 {
     QWriteLocker locker(&m_lock);
     m_effectStack->importEffects(std::move(stackModel), m_currentState);
     return true;
 }
 
 bool ClipModel::importEffects(std::weak_ptr<Mlt::Service> service)
 {
     QWriteLocker locker(&m_lock);
     m_effectStack->importEffects(std::move(service), m_currentState);
     return true;
 }
 
 bool ClipModel::removeFade(bool fromStart)
 {
     QWriteLocker locker(&m_lock);
     m_effectStack->removeFade(fromStart);
     return true;
 }
 
 bool ClipModel::adjustEffectLength(bool adjustFromEnd, int oldIn, int newIn, int oldDuration, int duration, int offset, Fun &undo, Fun &redo, bool logUndo)
 {
     QWriteLocker locker(&m_lock);
     return m_effectStack->adjustStackLength(adjustFromEnd, oldIn, oldDuration, newIn, duration, offset, undo, redo, logUndo);
 }
 
 bool ClipModel::adjustEffectLength(const QString &effectName, int duration, int originalDuration, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     qDebug() << ".... ADJUSTING FADE LENGTH: " << duration << " / " << effectName;
     Fun operation = [this, duration, effectName, originalDuration]() {
         return m_effectStack->adjustFadeLength(duration, effectName == QLatin1String("fadein") || effectName == QLatin1String("fade_to_black"), audioEnabled(),
                                                !isAudioOnly(), originalDuration > 0);
     };
     if (operation() && originalDuration > 0) {
         Fun reverse = [this, originalDuration, effectName]() {
             return m_effectStack->adjustFadeLength(originalDuration, effectName == QLatin1String("fadein") || effectName == QLatin1String("fade_to_black"),
                                                    audioEnabled(), !isAudioOnly(), true);
         };
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
     }
     return true;
 }
 
 bool ClipModel::audioEnabled() const
 {
     READ_LOCK();
     return stateToBool(m_currentState).second;
 }
 
 bool ClipModel::isAudioOnly() const
 {
     READ_LOCK();
     return m_currentState == PlaylistState::AudioOnly;
 }
 
 void ClipModel::refreshProducerFromBin(PlaylistState::ClipState state, double speed)
 {
     // We require that the producer is not in the track when we refresh the producer, because otherwise the modification will not be propagated. Remove the clip
     // first, refresh, and then replant.
     QWriteLocker locker(&m_lock);
     int in = getIn();
     int out = getOut();
     if (!qFuzzyCompare(speed, m_speed) && !qFuzzyCompare(speed, 0.)) {
         in = in * std::abs(m_speed / speed);
         out = in + getPlaytime() - 1;
         // prevent going out of the clip's range
         out = std::min(out, int(double(m_producer->get_length()) * std::abs(m_speed / speed)) - 1);
         m_speed = speed;
         qDebug() << "changing speed" << in << out << m_speed;
     }
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     std::shared_ptr<Mlt::Producer> binProducer = binClip->getTimelineProducer(m_currentTrackId, m_id, state, m_speed);
     m_producer = std::move(binProducer);
     m_producer->set_in_and_out(in, out);
     // replant effect stack in updated service
     m_effectStack->resetService(m_producer);
     m_producer->set("kdenlive:id", binClip->clipId().toUtf8().constData());
     m_producer->set("_kdenlive_cid", m_id);
     m_endlessResize = !binClip->hasLimitedDuration();
 }
 
 void ClipModel::refreshProducerFromBin()
 {
     refreshProducerFromBin(m_currentState);
 }
 
 bool ClipModel::useTimewarpProducer(double speed, bool changeDuration, Fun &undo, Fun &redo)
 {
     if (m_endlessResize) {
         // no timewarp for endless producers
         return false;
     }
     if (qFuzzyCompare(speed, m_speed)) {
         // nothing to do
         return true;
     }
     std::function<bool(void)> local_undo = []() { return true; };
     std::function<bool(void)> local_redo = []() { return true; };
     double previousSpeed = getSpeed();
     int oldDuration = getPlaytime();
     int newDuration = qRound(oldDuration * std::fabs(m_speed / speed));
     int oldOut = getOut();
     int oldIn = getIn();
     bool revertSpeed = false;
     if (speed < 0) {
         if (previousSpeed > 0) {
             revertSpeed = true;
         }
     } else if (previousSpeed < 0) {
         revertSpeed = true;
     }
     auto operation = useTimewarpProducer_lambda(speed);
     auto reverse = useTimewarpProducer_lambda(previousSpeed);
     if (revertSpeed || (changeDuration && oldOut >= newDuration)) {
         // in that case, we are going to shrink the clip when changing the producer. We must undo that when reloading the old producer
         reverse = [reverse, oldIn, oldOut, this]() {
             bool res = reverse();
             if (res) {
                 setInOut(oldIn, oldOut);
             }
             return res;
         };
     }
     if (revertSpeed) {
         int in = getIn();
         int out = getOut();
         in = qMax(0, qRound((m_producer->get_length() - 1 - out)* std::fabs(m_speed/speed) + 0.5));
         out = in + newDuration;
         operation = [operation, in, out, this]() {
             bool res = operation();
             if (res) {
                 setInOut(in, out);
             } else {
             }
             return res;
         };
 
     }
     if (operation()) {
         UPDATE_UNDO_REDO(operation, reverse, local_undo, local_redo);
         // When calculating duration, result can be a few frames longer than possible duration so adjust
         if (changeDuration) {
             int requestedDuration = qMin(newDuration, getMaxDuration() - getIn());
             if (requestedDuration != getPlaytime()) {
                 bool res = requestResize(requestedDuration, true, local_undo, local_redo, true);
                 if (!res) {
                     qDebug()<<"==== CLIP WARP UPDATE DURATION FAILED!!!!";
                     local_undo();
                     return false;
                 }
             }
         }
         adjustEffectLength(false, oldIn, getIn(), oldOut - oldIn, m_producer->get_playtime(), 0, local_undo, local_redo, true);
         UPDATE_UNDO_REDO(local_redo, local_undo, undo, redo);
         return true;
     }
     qDebug() << "tw: operation fail";
     return false;
 }
 
 Fun ClipModel::useTimewarpProducer_lambda(double speed)
 {
     QWriteLocker locker(&m_lock);
     return [speed, this]() {
         qDebug() << "timeWarp producer" << speed;
         refreshProducerFromBin(m_currentState, speed);
         if (auto ptr = m_parent.lock()) {
             QModelIndex ix = ptr->makeClipIndexFromID(m_id);
             ptr->notifyChange(ix, ix, TimelineModel::SpeedRole);
         }
         return true;
     };
 }
 
 QVariant ClipModel::getAudioWaveform()
 {
     READ_LOCK();
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     if (binClip) {
         return QVariant::fromValue(binClip->audioFrameCache);
     }
     return QVariant();
 }
 
 const QString &ClipModel::binId() const
 {
     return m_binClipId;
 }
 
 std::shared_ptr<MarkerListModel> ClipModel::getMarkerModel() const
 {
     READ_LOCK();
     return pCore->projectItemModel()->getClipByBinID(m_binClipId)->getMarkerModel();
 }
 
 int ClipModel::audioChannels() const
 {
     READ_LOCK();
     return pCore->projectItemModel()->getClipByBinID(m_binClipId)->audioChannels();
 }
 
 int ClipModel::fadeIn() const
 {
     return m_effectStack->getFadePosition(true);
 }
 
 int ClipModel::fadeOut() const
 {
     return m_effectStack->getFadePosition(false);
 }
 
 double ClipModel::getSpeed() const
 {
     return m_speed;
 }
 
 KeyframeModel *ClipModel::getKeyframeModel()
 {
     return m_effectStack->getEffectKeyframeModel();
 }
 
 bool ClipModel::showKeyframes() const
 {
     READ_LOCK();
     return !service()->get_int("kdenlive:hide_keyframes");
 }
 
 void ClipModel::setShowKeyframes(bool show)
 {
     QWriteLocker locker(&m_lock);
     service()->set("kdenlive:hide_keyframes", (int)!show);
 }
 
 void ClipModel::setPosition(int pos)
 {
     MoveableItem::setPosition(pos);
     m_clipMarkerModel->updateSnapModelPos(pos);
 }
 
 void ClipModel::setInOut(int in, int out)
 {
     MoveableItem::setInOut(in, out);
     m_clipMarkerModel->updateSnapModelInOut(std::pair<int, int>(in, out));
 }
 
 void ClipModel::setCurrentTrackId(int tid, bool finalMove)
 {
     if (tid == m_currentTrackId) {
         return;
     }
     bool registerSnap = m_currentTrackId == -1 && tid > -1;
 
     if (m_currentTrackId > -1 && tid == -1) {
         // Removing clip
         m_clipMarkerModel->deregisterSnapModel();
     }
     MoveableItem::setCurrentTrackId(tid, finalMove);
     if (registerSnap) {
         if (auto ptr = m_parent.lock()) {
             m_clipMarkerModel->registerSnapModel(ptr->m_snaps, getPosition(), getIn(), getOut(), m_speed);
         }
     }
 
     if (finalMove && tid != -1 && m_lastTrackId != m_currentTrackId) {
         refreshProducerFromBin(m_currentState);
         m_lastTrackId = m_currentTrackId;
     }
 }
 
 Fun ClipModel::setClipState_lambda(PlaylistState::ClipState state)
 {
     QWriteLocker locker(&m_lock);
     return [this, state]() {
         if (auto ptr = m_parent.lock()) {
             m_currentState = state;
             // Enforce producer reload
             m_lastTrackId = -1;
             if (m_currentTrackId != -1 && ptr->isClip(m_id)) { // if this is false, the clip is being created. Don't update model in that case
                 refreshProducerFromBin(m_currentState);
                 QModelIndex ix = ptr->makeClipIndexFromID(m_id);
                 ptr->dataChanged(ix, ix, {TimelineModel::StatusRole});
             }
             return true;
         }
         return false;
     };
 }
 
 bool ClipModel::setClipState(PlaylistState::ClipState state, Fun &undo, Fun &redo)
 {
     if (state == PlaylistState::VideoOnly && !canBeVideo()) {
         return false;
     }
     if (state == PlaylistState::AudioOnly && !canBeAudio()) {
         return false;
     }
     if (state == m_currentState) {
         return true;
     }
     auto old_state = m_currentState;
     auto operation = setClipState_lambda(state);
     if (operation()) {
         auto reverse = setClipState_lambda(old_state);
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 PlaylistState::ClipState ClipModel::clipState() const
 {
     READ_LOCK();
     return m_currentState;
 }
 
 ClipType::ProducerType ClipModel::clipType() const
 {
     READ_LOCK();
     return m_clipType;
 }
 
 void ClipModel::passTimelineProperties(const std::shared_ptr<ClipModel> &other)
 {
     READ_LOCK();
     Mlt::Properties source(m_producer->get_properties());
     Mlt::Properties dest(other->service()->get_properties());
     dest.pass_list(source, "kdenlive:hide_keyframes,kdenlive:activeeffect");
 }
 
 bool ClipModel::canBeVideo() const
 {
     return m_canBeVideo;
 }
 
 bool ClipModel::canBeAudio() const
 {
     return m_canBeAudio;
 }
 
 const QString ClipModel::effectNames() const
 {
     READ_LOCK();
     return m_effectStack->effectNames();
 }
 
 int ClipModel::getFakeTrackId() const
 {
     return m_fakeTrack;
 }
 
 void ClipModel::setFakeTrackId(int fid)
 {
     m_fakeTrack = fid;
 }
 
 int ClipModel::getFakePosition() const
 {
     return m_fakePosition;
 }
 
 void ClipModel::setFakePosition(int fid)
 {
     m_fakePosition = fid;
 }
 
 QDomElement ClipModel::toXml(QDomDocument &document)
 {
     QDomElement container = document.createElement(QStringLiteral("clip"));
     container.setAttribute(QStringLiteral("binid"), m_binClipId);
     container.setAttribute(QStringLiteral("id"), m_id);
     container.setAttribute(QStringLiteral("in"), getIn());
     container.setAttribute(QStringLiteral("out"), getOut());
     container.setAttribute(QStringLiteral("position"), getPosition());
     container.setAttribute(QStringLiteral("state"), (int)m_currentState);
     if (auto ptr = m_parent.lock()) {
         int trackId = ptr->getTrackPosition(m_currentTrackId);
         container.setAttribute(QStringLiteral("track"), trackId);
         if (ptr->isAudioTrack(getCurrentTrackId())) {
             container.setAttribute(QStringLiteral("audioTrack"), 1);
             int partner = ptr->getClipSplitPartner(m_id);
             if (partner != -1) {
                 int mirrorId = ptr->getMirrorVideoTrackId(m_currentTrackId);
                 if (mirrorId > -1) {
                     mirrorId = ptr->getTrackPosition(mirrorId);
                 }
                 container.setAttribute(QStringLiteral("mirrorTrack"), mirrorId);
             } else {
                 container.setAttribute(QStringLiteral("mirrorTrack"), QStringLiteral("-1"));
             }
         }
     }
     container.setAttribute(QStringLiteral("speed"), m_speed);
     container.appendChild(m_effectStack->toXml(document));
     return container;
 }
 
 bool ClipModel::checkConsistency()
 {
     if (!m_effectStack->checkConsistency()) {
         qDebug() << "Consistency check failed for effecstack";
         return false;
     }
     std::shared_ptr<ProjectClip> binClip = pCore->projectItemModel()->getClipByBinID(m_binClipId);
     auto instances = binClip->timelineInstances();
     bool found = false;
     for (const auto &i : instances) {
         if (i == m_id) {
             found = true;
             break;
         }
     }
     if (!found) {
         qDebug() << "ERROR: binClip doesn't acknowledge timeline clip existence";
         return false;
     }
 
     if (m_currentState == PlaylistState::VideoOnly && !m_canBeVideo) {
         qDebug() << "ERROR: clip is in video state but doesn't have video";
         return false;
     }
     if (m_currentState == PlaylistState::AudioOnly && !m_canBeAudio) {
         qDebug() << "ERROR: clip is in video state but doesn't have video";
         return false;
     }
     // TODO: check speed
 
     return true;
 }
 
 int ClipModel::getSubPlaylistIndex() const
 {
     return m_subPlaylistIndex;
 }
 
 void ClipModel::setSubPlaylistIndex(int index)
 {
     m_subPlaylistIndex = index;
 }
 
 void ClipModel::setOffset(int offset)
 {
     m_positionOffset = offset;
     if (auto ptr = m_parent.lock()) {
         QModelIndex ix = ptr->makeClipIndexFromID(m_id);
         ptr->dataChanged(ix, ix, {TimelineModel::PositionOffsetRole});
     }
 }
 
 void ClipModel::setGrab(bool grab)
 {
     QWriteLocker locker(&m_lock);
     if (grab == m_grabbed) {
         return;
     }
     m_grabbed = grab;
     if (auto ptr = m_parent.lock()) {
         QModelIndex ix = ptr->makeClipIndexFromID(m_id);
         ptr->dataChanged(ix, ix, {TimelineModel::GrabbedRole});
     }
 }
 
 void ClipModel::setSelected(bool sel)
 {
     QWriteLocker locker(&m_lock);
     if (sel == selected) {
         return;
     }
     selected = sel;
     if (auto ptr = m_parent.lock()) {
         if (m_currentTrackId != -1) {
             QModelIndex ix = ptr->makeClipIndexFromID(m_id);
             ptr->dataChanged(ix, ix, {TimelineModel::SelectedRole});
         }
     }
 }
 
 void ClipModel::clearOffset()
 {
     if (m_positionOffset != 0) {
         setOffset(0);
     }
 }
 
 int ClipModel::getOffset() const
 {
     return m_positionOffset;
 }
 
 int ClipModel::getMaxDuration() const
 {
     READ_LOCK();
     if (m_endlessResize) {
         return -1;
     }
     return m_producer->get_length();
 }
 
diff --git a/src/timeline2/model/trackmodel.cpp b/src/timeline2/model/trackmodel.cpp
index 8ae458e7e..3771ddc58 100644
--- a/src/timeline2/model/trackmodel.cpp
+++ b/src/timeline2/model/trackmodel.cpp
@@ -1,1279 +1,1301 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Nicolas Carion                                  *
  *   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 "trackmodel.hpp"
 #include "clipmodel.hpp"
 #include "compositionmodel.hpp"
 #include "effects/effectstack/model/effectstackmodel.hpp"
 #include "kdenlivesettings.h"
 #include "logger.hpp"
 #include "snapmodel.hpp"
 #include "timelinemodel.hpp"
 #include <QDebug>
 #include <QModelIndex>
 #include <mlt++/MltTransition.h>
 
 TrackModel::TrackModel(const std::weak_ptr<TimelineModel> &parent, int id, const QString &trackName, bool audioTrack)
     : m_parent(parent)
     , m_id(id == -1 ? TimelineModel::getNextId() : id)
     , m_lock(QReadWriteLock::Recursive)
 {
     if (auto ptr = parent.lock()) {
         m_track = std::make_shared<Mlt::Tractor>(*ptr->getProfile());
         m_playlists[0].set_profile(*ptr->getProfile());
         m_playlists[1].set_profile(*ptr->getProfile());
         m_track->insert_track(m_playlists[0], 0);
         m_track->insert_track(m_playlists[1], 1);
         if (!trackName.isEmpty()) {
             m_track->set("kdenlive:track_name", trackName.toUtf8().constData());
         }
         if (audioTrack) {
             m_track->set("kdenlive:audio_track", 1);
             for (auto &m_playlist : m_playlists) {
                 m_playlist.set("hide", 1);
             }
         }
         m_track->set("kdenlive:trackheight", KdenliveSettings::trackheight());
         m_effectStack = EffectStackModel::construct(m_track, {ObjectType::TimelineTrack, m_id}, ptr->m_undoStack);
         QObject::connect(m_effectStack.get(), &EffectStackModel::dataChanged, [&](const QModelIndex &, const QModelIndex &, QVector<int> roles) {
             if (auto ptr2 = m_parent.lock()) {
                 QModelIndex ix = ptr2->makeTrackIndexFromID(m_id);
                 ptr2->dataChanged(ix, ix, roles);
             }
         });
     } else {
         qDebug() << "Error : construction of track failed because parent timeline is not available anymore";
         Q_ASSERT(false);
     }
 }
 
 TrackModel::TrackModel(const std::weak_ptr<TimelineModel> &parent, Mlt::Tractor mltTrack, int id)
     : m_parent(parent)
     , m_id(id == -1 ? TimelineModel::getNextId() : id)
 {
     if (auto ptr = parent.lock()) {
         m_track = std::make_shared<Mlt::Tractor>(mltTrack);
         m_playlists[0] = *m_track->track(0);
         m_playlists[1] = *m_track->track(1);
         m_effectStack = EffectStackModel::construct(m_track, {ObjectType::TimelineTrack, m_id}, ptr->m_undoStack);
     } else {
         qDebug() << "Error : construction of track failed because parent timeline is not available anymore";
         Q_ASSERT(false);
     }
 }
 
 TrackModel::~TrackModel()
 {
     m_track->remove_track(1);
     m_track->remove_track(0);
 }
 
 int TrackModel::construct(const std::weak_ptr<TimelineModel> &parent, int id, int pos, const QString &trackName, bool audioTrack)
 {
     std::shared_ptr<TrackModel> track(new TrackModel(parent, id, trackName, audioTrack));
     TRACE_CONSTR(track.get(), parent, id, pos, trackName, audioTrack);
     id = track->m_id;
     if (auto ptr = parent.lock()) {
         ptr->registerTrack(std::move(track), pos);
     } else {
         qDebug() << "Error : construction of track failed because parent timeline is not available anymore";
         Q_ASSERT(false);
     }
     return id;
 }
 
 int TrackModel::getClipsCount()
 {
     READ_LOCK();
 #ifdef QT_DEBUG
     int count = 0;
     for (auto &m_playlist : m_playlists) {
         for (int i = 0; i < m_playlist.count(); i++) {
             if (!m_playlist.is_blank(i)) {
                 count++;
             }
         }
     }
     Q_ASSERT(count == static_cast<int>(m_allClips.size()));
 #else
     int count = (int)m_allClips.size();
 #endif
     return count;
 }
 
 Fun TrackModel::requestClipInsertion_lambda(int clipId, int position, bool updateView, bool finalMove, bool groupMove)
 {
     QWriteLocker locker(&m_lock);
     // By default, insertion occurs in topmost track
     // Find out the clip id at position
     int target_clip = m_playlists[0].get_clip_index_at(position);
     int count = m_playlists[0].count();
     if (auto ptr = m_parent.lock()) {
         Q_ASSERT(ptr->getClipPtr(clipId)->getCurrentTrackId() == -1);
     } else {
         qDebug() << "impossible to get parent timeline";
         Q_ASSERT(false);
     }
 
     // we create the function that has to be executed after the melt order. This is essentially book-keeping
     auto end_function = [clipId, this, position, updateView, finalMove](int subPlaylist) {
         if (auto ptr = m_parent.lock()) {
             std::shared_ptr<ClipModel> clip = ptr->getClipPtr(clipId);
             m_allClips[clip->getId()] = clip; // store clip
             // update clip position and track
             clip->setPosition(position);
             clip->setSubPlaylistIndex(subPlaylist);
             int new_in = clip->getPosition();
             int new_out = new_in + clip->getPlaytime();
             ptr->m_snaps->addPoint(new_in);
             ptr->m_snaps->addPoint(new_out);
             if (updateView) {
                 int clip_index = getRowfromClip(clipId);
                 ptr->_beginInsertRows(ptr->makeTrackIndexFromID(m_id), clip_index, clip_index);
                 ptr->_endInsertRows();
                 bool audioOnly = clip->isAudioOnly();
                 if (!audioOnly && !isHidden() && !isAudioTrack()) {
                     // only refresh monitor if not an audio track and not hidden
                     ptr->checkRefresh(new_in, new_out);
                 }
                 if (!audioOnly && finalMove && !isAudioTrack()) {
                     ptr->invalidateZone(new_in, new_out);
                 }
             }
             return true;
         }
         qDebug() << "Error : Clip Insertion failed because timeline is not available anymore";
         return false;
     };
     if (target_clip >= count && isBlankAt(position)) {
         // In that case, we append after, in the first playlist
         return [this, position, clipId, end_function, finalMove, groupMove]() {
             if (isLocked()) return false;
             if (auto ptr = m_parent.lock()) {
                 // Lock MLT playlist so that we don't end up with an invalid frame being displayed
                 m_playlists[0].lock();
                 std::shared_ptr<ClipModel> clip = ptr->getClipPtr(clipId);
                 clip->setCurrentTrackId(m_id, finalMove);
                 int index = m_playlists[0].insert_at(position, *clip, 1);
                 m_playlists[0].consolidate_blanks();
                 m_playlists[0].unlock();
                 if (finalMove && !groupMove) {
                     ptr->updateDuration();
+                    
                 }
                 return index != -1 && end_function(0);
             }
             qDebug() << "Error : Clip Insertion failed because timeline is not available anymore";
             return false;
         };
     }
     if (isBlankAt(position)) {
         int blank_end = getBlankEnd(position);
         int length = -1;
         if (auto ptr = m_parent.lock()) {
             std::shared_ptr<ClipModel> clip = ptr->getClipPtr(clipId);
             length = clip->getPlaytime();
         }
         if (blank_end >= position + length) {
             return [this, position, clipId, end_function]() {
                 if (isLocked()) return false;
                 if (auto ptr = m_parent.lock()) {
                     // Lock MLT playlist so that we don't end up with an invalid frame being displayed
                     m_playlists[0].lock();
                     std::shared_ptr<ClipModel> clip = ptr->getClipPtr(clipId);
                     clip->setCurrentTrackId(m_id);
                     int index = m_playlists[0].insert_at(position, *clip, 1);
                     m_playlists[0].consolidate_blanks();
                     m_playlists[0].unlock();
                     return index != -1 && end_function(0);
                 }
                 qDebug() << "Error : Clip Insertion failed because timeline is not available anymore";
                 return false;
             };
         }
     }
     return []() { return false; };
 }
 
 bool TrackModel::requestClipInsertion(int clipId, int position, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool groupMove)
 {
     QWriteLocker locker(&m_lock);
     if (isLocked()) {
         return false;
     }
     if (position < 0) {
         return false;
     }
     if (auto ptr = m_parent.lock()) {
         if (isAudioTrack() && !ptr->getClipPtr(clipId)->canBeAudio()) {
             qDebug() << "// ATTEMPTING TO INSERT NON AUDIO CLIP ON AUDIO TRACK";
             return false;
         }
         if (!isAudioTrack() && !ptr->getClipPtr(clipId)->canBeVideo()) {
             qDebug() << "// ATTEMPTING TO INSERT NON VIDEO CLIP ON VIDEO TRACK";
             return false;
         }
         Fun local_undo = []() { return true; };
         Fun local_redo = []() { return true; };
         bool res = true;
         if (ptr->getClipPtr(clipId)->clipState() != PlaylistState::Disabled) {
             res = res && ptr->getClipPtr(clipId)->setClipState(isAudioTrack() ? PlaylistState::AudioOnly : PlaylistState::VideoOnly, local_undo, local_redo);
         }
+        int duration = trackDuration();
         auto operation = requestClipInsertion_lambda(clipId, position, updateView, finalMove, groupMove);
         res = res && operation();
         if (res) {
+            if (finalMove && duration != trackDuration()) {
+                // A clip move changed the track duration, update track effects
+                m_effectStack->adjustStackLength(true, 0, duration, 0, trackDuration(), 0, undo, redo, true);
+            }
             auto reverse = requestClipDeletion_lambda(clipId, updateView, finalMove, groupMove);
             UPDATE_UNDO_REDO(operation, reverse, local_undo, local_redo);
             UPDATE_UNDO_REDO(local_redo, local_undo, undo, redo);
             return true;
         }
         bool undone = local_undo();
         Q_ASSERT(undone);
         return false;
     }
     return false;
 }
 
 void TrackModel::replugClip(int clipId)
 {
     QWriteLocker locker(&m_lock);
     int clip_position = m_allClips[clipId]->getPosition();
     auto clip_loc = getClipIndexAt(clip_position);
     int target_track = clip_loc.first;
     int target_clip = clip_loc.second;
     // lock MLT playlist so that we don't end up with invalid frames in monitor
     m_playlists[target_track].lock();
     Q_ASSERT(target_clip < m_playlists[target_track].count());
     Q_ASSERT(!m_playlists[target_track].is_blank(target_clip));
     std::unique_ptr<Mlt::Producer> prod(m_playlists[target_track].replace_with_blank(target_clip));
     if (auto ptr = m_parent.lock()) {
         std::shared_ptr<ClipModel> clip = ptr->getClipPtr(clipId);
         m_playlists[target_track].insert_at(clip_position, *clip, 1);
         if (!clip->isAudioOnly() && !isAudioTrack()) {
             ptr->invalidateZone(clip->getIn(), clip->getOut());
         }
         if (!clip->isAudioOnly() && !isHidden() && !isAudioTrack()) {
             // only refresh monitor if not an audio track and not hidden
             ptr->checkRefresh(clip->getIn(), clip->getOut());
         }
     }
     m_playlists[target_track].consolidate_blanks();
     m_playlists[target_track].unlock();
 }
 
 Fun TrackModel::requestClipDeletion_lambda(int clipId, bool updateView, bool finalMove, bool groupMove)
 {
     QWriteLocker locker(&m_lock);
     // Find index of clip
     int clip_position = m_allClips[clipId]->getPosition();
     bool audioOnly = m_allClips[clipId]->isAudioOnly();
     int old_in = clip_position;
     int old_out = old_in + m_allClips[clipId]->getPlaytime();
     return [clip_position, clipId, old_in, old_out, updateView, audioOnly, finalMove, groupMove, this]() {
         if (isLocked()) return false;
         auto clip_loc = getClipIndexAt(clip_position);
         if (updateView) {
             int old_clip_index = getRowfromClip(clipId);
             auto ptr = m_parent.lock();
             ptr->_beginRemoveRows(ptr->makeTrackIndexFromID(getId()), old_clip_index, old_clip_index);
             ptr->_endRemoveRows();
         }
         int target_track = m_allClips[clipId]->getSubPlaylistIndex();
         int target_clip = clip_loc.second;
         // lock MLT playlist so that we don't end up with invalid frames in monitor
         m_playlists[target_track].lock();
         Q_ASSERT(target_clip < m_playlists[target_track].count());
         Q_ASSERT(!m_playlists[target_track].is_blank(target_clip));
         auto prod = m_playlists[target_track].replace_with_blank(target_clip);
         if (prod != nullptr) {
             m_playlists[target_track].consolidate_blanks();
             m_allClips[clipId]->setCurrentTrackId(-1);
             m_allClips[clipId]->setSubPlaylistIndex(-1);
             m_allClips.erase(clipId);
             delete prod;
             m_playlists[target_track].unlock();
             if (auto ptr = m_parent.lock()) {
                 ptr->m_snaps->removePoint(old_in);
                 ptr->m_snaps->removePoint(old_out);
                 if (finalMove) {
                     if (!audioOnly && !isAudioTrack()) {
                         ptr->invalidateZone(old_in, old_out);
                     }
                     if (!groupMove && target_clip >= m_playlists[target_track].count()) {
                         // deleted last clip in playlist
                         ptr->updateDuration();
                     }
                 }
                 if (!audioOnly && !isHidden() && !isAudioTrack()) {
                     // only refresh monitor if not an audio track and not hidden
                     ptr->checkRefresh(old_in, old_out);
                 }
             }
             return true;
         }
         m_playlists[target_track].unlock();
         return false;
     };
 }
 
 bool TrackModel::requestClipDeletion(int clipId, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool groupMove, bool finalDeletion)
 {
     QWriteLocker locker(&m_lock);
     Q_ASSERT(m_allClips.count(clipId) > 0);
     if (isLocked()) {
         return false;
     }
     auto old_clip = m_allClips[clipId];
     int old_position = old_clip->getPosition();
     // qDebug() << "/// REQUESTOING CLIP DELETION_: " << updateView;
     if (finalDeletion) {
         m_allClips[clipId]->selected = false;
     }
+    int duration = trackDuration();
     auto operation = requestClipDeletion_lambda(clipId, updateView, finalMove, groupMove);
     if (operation()) {
+        if (finalMove && duration != trackDuration()) {
+            // A clip move changed the track duration, update track effects
+            m_effectStack->adjustStackLength(true, 0, duration, 0, trackDuration(), 0, undo, redo, true);
+        }
         auto reverse = requestClipInsertion_lambda(clipId, old_position, updateView, finalMove, groupMove);
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 int TrackModel::getBlankSizeAtPos(int frame)
 {
     READ_LOCK();
     int min_length = 0;
     for (auto &m_playlist : m_playlists) {
         int ix = m_playlist.get_clip_index_at(frame);
         if (m_playlist.is_blank(ix)) {
             int blank_length = m_playlist.clip_length(ix);
             if (min_length == 0 || (blank_length > 0 && blank_length < min_length)) {
                 min_length = blank_length;
             }
         }
     }
     return min_length;
 }
 
 int TrackModel::suggestCompositionLength(int position)
 {
     READ_LOCK();
     if (m_playlists[0].is_blank_at(position) && m_playlists[1].is_blank_at(position)) {
         return -1;
     }
     auto clip_loc = getClipIndexAt(position);
     int track = clip_loc.first;
     int index = clip_loc.second;
     int other_index; // index in the other track
     int other_track = (track + 1) % 2;
     int end_pos = m_playlists[track].clip_start(index) + m_playlists[track].clip_length(index);
     other_index = m_playlists[other_track].get_clip_index_at(end_pos);
     if (other_index < m_playlists[other_track].count()) {
         end_pos = std::min(end_pos, m_playlists[other_track].clip_start(other_index) + m_playlists[other_track].clip_length(other_index));
     }
     int min = -1;
     std::unordered_set<int> existing = getCompositionsInRange(position, end_pos);
     if (existing.size() > 0) {
         for (int id : existing) {
             if (min < 0) {
                 min = m_allCompositions[id]->getPosition();
             } else {
                 min = qMin(min, m_allCompositions[id]->getPosition());
             }
         }
     }
     if (min >= 0) {
         // An existing composition is limiting the space
         end_pos = min;
     }
     return end_pos - position;
 }
 
 int TrackModel::getBlankSizeNearClip(int clipId, bool after)
 {
     READ_LOCK();
     Q_ASSERT(m_allClips.count(clipId) > 0);
     int clip_position = m_allClips[clipId]->getPosition();
     auto clip_loc = getClipIndexAt(clip_position);
     int track = clip_loc.first;
     int index = clip_loc.second;
     int other_index; // index in the other track
     int other_track = (track + 1) % 2;
     if (after) {
         int first_pos = m_playlists[track].clip_start(index) + m_playlists[track].clip_length(index);
         other_index = m_playlists[other_track].get_clip_index_at(first_pos);
         index++;
     } else {
         int last_pos = m_playlists[track].clip_start(index) - 1;
         other_index = m_playlists[other_track].get_clip_index_at(last_pos);
         index--;
     }
     if (index < 0) return 0;
     int length = INT_MAX;
     if (index < m_playlists[track].count()) {
         if (!m_playlists[track].is_blank(index)) {
             return 0;
         }
         length = std::min(length, m_playlists[track].clip_length(index));
     }
     if (other_index < m_playlists[other_track].count()) {
         if (!m_playlists[other_track].is_blank(other_index)) {
             return 0;
         }
         length = std::min(length, m_playlists[other_track].clip_length(other_index));
     }
     return length;
 }
 
 int TrackModel::getBlankSizeNearComposition(int compoId, bool after)
 {
     READ_LOCK();
     Q_ASSERT(m_allCompositions.count(compoId) > 0);
     int clip_position = m_allCompositions[compoId]->getPosition();
     Q_ASSERT(m_compoPos.count(clip_position) > 0);
     Q_ASSERT(m_compoPos[clip_position] == compoId);
     auto it = m_compoPos.find(clip_position);
     int clip_length = m_allCompositions[compoId]->getPlaytime();
     int length = INT_MAX;
     if (after) {
         ++it;
         if (it != m_compoPos.end()) {
             return it->first - clip_position - clip_length;
         }
     } else {
         if (it != m_compoPos.begin()) {
             --it;
             return clip_position - it->first - m_allCompositions[it->second]->getPlaytime();
         }
         return clip_position;
     }
     return length;
 }
 
 Fun TrackModel::requestClipResize_lambda(int clipId, int in, int out, bool right)
 {
     QWriteLocker locker(&m_lock);
     int clip_position = m_allClips[clipId]->getPosition();
     int old_in = clip_position;
     int old_out = old_in + m_allClips[clipId]->getPlaytime();
     auto clip_loc = getClipIndexAt(clip_position);
     int target_track = clip_loc.first;
     int target_clip = clip_loc.second;
     Q_ASSERT(target_clip < m_playlists[target_track].count());
     int size = out - in + 1;
     bool checkRefresh = false;
     if (!isHidden() && !isAudioTrack()) {
         checkRefresh = true;
     }
 
     auto update_snaps = [old_in, old_out, checkRefresh, right, this](int new_in, int new_out) {
         if (auto ptr = m_parent.lock()) {
             ptr->m_snaps->removePoint(old_in);
             ptr->m_snaps->removePoint(old_out);
             ptr->m_snaps->addPoint(new_in);
             ptr->m_snaps->addPoint(new_out);
             if (checkRefresh) {
                 if (right) {
                     if (old_out < new_out) {
                         ptr->checkRefresh(old_out, new_out);
                     } else {
                         ptr->checkRefresh(old_in, old_out);
                     }
                 } else if (old_in < new_in) {
                     ptr->checkRefresh(old_in, new_in);
                 } else {
                     ptr->checkRefresh(new_in, old_in);
                 }
             }
         } else {
             qDebug() << "Error : clip resize failed because parent timeline is not available anymore";
             Q_ASSERT(false);
         }
     };
 
     int delta = m_allClips[clipId]->getPlaytime() - size;
     if (delta == 0) {
         return []() { return true; };
     }
     // qDebug() << "RESIZING CLIP: " << clipId << " FROM: " << delta;
     if (delta > 0) { // we shrink clip
         return [right, target_clip, target_track, clip_position, delta, in, out, clipId, update_snaps, this]() {
             if (isLocked()) return false;
             int target_clip_mutable = target_clip;
             int blank_index = right ? (target_clip_mutable + 1) : target_clip_mutable;
             // insert blank to space that is going to be empty
             m_playlists[target_track].lock();
             // The second is parameter is delta - 1 because this function expects an out time, which is basically size - 1
             m_playlists[target_track].insert_blank(blank_index, delta - 1);
             if (!right) {
                 m_allClips[clipId]->setPosition(clip_position + delta);
                 // Because we inserted blank before, the index of our clip has increased
                 target_clip_mutable++;
             }
             int err = m_playlists[target_track].resize_clip(target_clip_mutable, in, out);
             // make sure to do this after, to avoid messing the indexes
             m_playlists[target_track].consolidate_blanks();
             m_playlists[target_track].unlock();
             if (err == 0) {
                 update_snaps(m_allClips[clipId]->getPosition(), m_allClips[clipId]->getPosition() + out - in + 1);
                 if (right && m_playlists[target_track].count() - 1 == target_clip_mutable) {
                     // deleted last clip in playlist
                     if (auto ptr = m_parent.lock()) {
                         ptr->updateDuration();
                     }
                 }
             }
             return err == 0;
         };
     }
     int blank = -1;
     int other_blank_end = getBlankEnd(clip_position, (target_track + 1) % 2);
     if (right) {
         if (target_clip == m_playlists[target_track].count() - 1 && other_blank_end >= out) {
             // clip is last, it can always be extended
             return [this, target_clip, target_track, in, out, update_snaps, clipId]() {
                 if (isLocked()) return false;
                 // color, image and title clips can have unlimited resize
                 QScopedPointer<Mlt::Producer> clip(m_playlists[target_track].get_clip(target_clip));
                 if (out >= clip->get_length()) {
                     clip->parent().set("length", out + 1);
                     clip->parent().set("out", out);
                     clip->set("length", out + 1);
                 }
                 int err = m_playlists[target_track].resize_clip(target_clip, in, out);
                 if (err == 0) {
                     update_snaps(m_allClips[clipId]->getPosition(), m_allClips[clipId]->getPosition() + out - in + 1);
                 }
                 m_playlists[target_track].consolidate_blanks();
                 if (m_playlists[target_track].count() - 1 == target_clip) {
                     // deleted last clip in playlist
                     if (auto ptr = m_parent.lock()) {
                         ptr->updateDuration();
                     }
                 }
                 return err == 0;
             };
         }
 
         blank = target_clip + 1;
     } else {
         if (target_clip == 0) {
             // clip is first, it can never be extended on the left
             return []() { return false; };
         }
         blank = target_clip - 1;
     }
     if (m_playlists[target_track].is_blank(blank)) {
         int blank_length = m_playlists[target_track].clip_length(blank);
         if (blank_length + delta >= 0 && other_blank_end >= out) {
             return [blank_length, blank, right, clipId, delta, update_snaps, this, in, out, target_clip, target_track]() {
                 if (isLocked()) return false;
                 int target_clip_mutable = target_clip;
                 int err = 0;
                 m_playlists[target_track].lock();
                 if (blank_length + delta == 0) {
                     err = m_playlists[target_track].remove(blank);
                     if (!right) {
                         target_clip_mutable--;
                     }
                 } else {
                     err = m_playlists[target_track].resize_clip(blank, 0, blank_length + delta - 1);
                 }
                 if (err == 0) {
                     QScopedPointer<Mlt::Producer> clip(m_playlists[target_track].get_clip(target_clip_mutable));
                     if (out >= clip->get_length()) {
                         clip->parent().set("length", out + 1);
                         clip->parent().set("out", out);
                         clip->set("length", out + 1);
                     }
                     err = m_playlists[target_track].resize_clip(target_clip_mutable, in, out);
                 }
                 if (!right && err == 0) {
                     m_allClips[clipId]->setPosition(m_playlists[target_track].clip_start(target_clip_mutable));
                 }
                 if (err == 0) {
                     update_snaps(m_allClips[clipId]->getPosition(), m_allClips[clipId]->getPosition() + out - in + 1);
                 }
                 m_playlists[target_track].consolidate_blanks();
                 m_playlists[target_track].unlock();
                 return err == 0;
             };
         }
     }
 
     return []() { return false; };
 }
 
 int TrackModel::getId() const
 {
     return m_id;
 }
 
 int TrackModel::getClipByPosition(int position)
 {
     READ_LOCK();
     QSharedPointer<Mlt::Producer> prod(nullptr);
     if (m_playlists[0].count() > 0) {
         prod = QSharedPointer<Mlt::Producer>(m_playlists[0].get_clip_at(position));
     }
     if ((!prod || prod->is_blank()) && m_playlists[1].count() > 0) {
         prod = QSharedPointer<Mlt::Producer>(m_playlists[1].get_clip_at(position));
     }
     if (!prod || prod->is_blank()) {
         return -1;
     }
     return prod->get_int("_kdenlive_cid");
 }
 
 QSharedPointer<Mlt::Producer> TrackModel::getClipProducer(int clipId)
 {
     READ_LOCK();
     QSharedPointer<Mlt::Producer> prod(nullptr);
     if (m_playlists[0].count() > 0) {
         prod = QSharedPointer<Mlt::Producer>(m_playlists[0].get_clip(clipId));
     }
     if ((!prod || prod->is_blank()) && m_playlists[1].count() > 0) {
         prod = QSharedPointer<Mlt::Producer>(m_playlists[1].get_clip(clipId));
     }
     return prod;
 }
 
 int TrackModel::getCompositionByPosition(int position)
 {
     READ_LOCK();
     for (const auto &comp : m_compoPos) {
         if (comp.first == position) {
             return comp.second;
         } else if (comp.first < position) {
             if (comp.first + m_allCompositions[comp.second]->getPlaytime() >= position) {
                 return comp.second;
             }
         }
     }
     return -1;
 }
 
 int TrackModel::getClipByRow(int row) const
 {
     READ_LOCK();
     if (row >= static_cast<int>(m_allClips.size())) {
         return -1;
     }
     auto it = m_allClips.cbegin();
     std::advance(it, row);
     return (*it).first;
 }
 
 std::unordered_set<int> TrackModel::getClipsInRange(int position, int end)
 {
     READ_LOCK();
     std::unordered_set<int> ids;
     for (const auto &clp : m_allClips) {
         int pos = clp.second->getPosition();
         int length = clp.second->getPlaytime();
         if (end > -1 && pos >= end) {
             continue;
         }
         if (pos >= position || pos + length - 1 >= position) {
             ids.insert(clp.first);
         }
     }
     return ids;
 }
 
 int TrackModel::getRowfromClip(int clipId) const
 {
     READ_LOCK();
     Q_ASSERT(m_allClips.count(clipId) > 0);
     return (int)std::distance(m_allClips.begin(), m_allClips.find(clipId));
 }
 
 std::unordered_set<int> TrackModel::getCompositionsInRange(int position, int end)
 {
     READ_LOCK();
     // TODO: this function doesn't take into accounts the fact that there are two tracks
     std::unordered_set<int> ids;
     for (const auto &compo : m_allCompositions) {
         int pos = compo.second->getPosition();
         int length = compo.second->getPlaytime();
         if (end > -1 && pos >= end) {
             continue;
         }
         if (pos >= position || pos + length - 1 >= position) {
             ids.insert(compo.first);
         }
     }
     return ids;
 }
 
 int TrackModel::getRowfromComposition(int tid) const
 {
     READ_LOCK();
     Q_ASSERT(m_allCompositions.count(tid) > 0);
     return (int)m_allClips.size() + (int)std::distance(m_allCompositions.begin(), m_allCompositions.find(tid));
 }
 
 QVariant TrackModel::getProperty(const QString &name) const
 {
     READ_LOCK();
     return QVariant(m_track->get(name.toUtf8().constData()));
 }
 
 void TrackModel::setProperty(const QString &name, const QString &value)
 {
     QWriteLocker locker(&m_lock);
     m_track->set(name.toUtf8().constData(), value.toUtf8().constData());
     // Hide property mus be defined at playlist level or it won't be saved
     if (name == QLatin1String("kdenlive:audio_track") || name == QLatin1String("hide")) {
         for (auto &m_playlist : m_playlists) {
             m_playlist.set(name.toUtf8().constData(), value.toInt());
         }
     }
 }
 
 bool TrackModel::checkConsistency()
 {
     auto ptr = m_parent.lock();
     if (!ptr) {
         return false;
     }
     auto check_blank_zone = [&](int playlist, int in, int out) {
         if (in >= m_playlists[playlist].get_playtime()) {
             return true;
         }
         int index = m_playlists[playlist].get_clip_index_at(in);
         if (!m_playlists[playlist].is_blank(index)) {
             return false;
         }
         int cin = m_playlists[playlist].clip_start(index);
         if (cin > in) {
             return false;
         }
         if (cin + m_playlists[playlist].clip_length(index) - 1 < out) {
             return false;
         }
         return true;
     };
     std::vector<std::pair<int, int>> clips; // clips stored by (position, id)
     for (const auto &c : m_allClips) {
         Q_ASSERT(c.second);
         Q_ASSERT(c.second.get() == ptr->getClipPtr(c.first).get());
         clips.emplace_back(c.second->getPosition(), c.first);
     }
     std::sort(clips.begin(), clips.end());
     int last_out = 0;
     for (size_t i = 0; i < clips.size(); ++i) {
         auto cur_clip = m_allClips[clips[i].second];
         if (last_out < clips[i].first) {
             // we have some blank space before this clip, check it
             for (int pl = 0; pl <= 1; ++pl) {
                 if (!check_blank_zone(pl, last_out, clips[i].first - 1)) {
                     qDebug() << "ERROR: Some blank was required on playlist " << pl << " between " << last_out << " and " << clips[i].first - 1;
                     return false;
                 }
             }
         }
         int cur_playlist = cur_clip->getSubPlaylistIndex();
         int clip_index = m_playlists[cur_playlist].get_clip_index_at(clips[i].first);
         if (m_playlists[cur_playlist].is_blank(clip_index)) {
             qDebug() << "ERROR: Found blank when clip was required at position " << clips[i].first;
             return false;
         }
         if (m_playlists[cur_playlist].clip_start(clip_index) != clips[i].first) {
             qDebug() << "ERROR: Inconsistent start position for clip at position " << clips[i].first;
             return false;
         }
         if (m_playlists[cur_playlist].clip_start(clip_index) != clips[i].first) {
             qDebug() << "ERROR: Inconsistent start position for clip at position " << clips[i].first;
             return false;
         }
         if (m_playlists[cur_playlist].clip_length(clip_index) != cur_clip->getPlaytime()) {
             qDebug() << "ERROR: Inconsistent length for clip at position " << clips[i].first;
             return false;
         }
         auto pr = m_playlists[cur_playlist].get_clip(clip_index);
         Mlt::Producer prod(pr);
         if (!prod.same_clip(*cur_clip)) {
             qDebug() << "ERROR: Wrong clip at position " << clips[i].first;
             delete pr;
             return false;
         }
         delete pr;
 
         // the current playlist is valid, we check that the other is essentially blank
         int other_playlist = (cur_playlist + 1) % 2;
         int in_blank = clips[i].first;
         int out_blank = clips[i].first + cur_clip->getPlaytime() - 1;
 
         // the previous clip on the same playlist must not intersect
         int prev_clip_id_same_playlist = -1;
         for (int j = (int)i - 1; j >= 0; --j) {
             if (cur_playlist == m_allClips[clips[(size_t)j].second]->getSubPlaylistIndex()) {
                 prev_clip_id_same_playlist = j;
                 break;
             }
         }
         if (prev_clip_id_same_playlist >= 0 &&
             clips[(size_t)prev_clip_id_same_playlist].first + m_allClips[clips[(size_t)prev_clip_id_same_playlist].second]->getPlaytime() > clips[i].first) {
             qDebug() << "ERROR: found overlapping clips at position " << clips[i].first;
             return false;
         }
 
         // the previous clip on the other playlist might restrict the blank in/out
         int prev_clip_id_other_playlist = -1;
         for (int j = (int)i - 1; j >= 0; --j) {
             if (other_playlist == m_allClips[clips[(size_t)j].second]->getSubPlaylistIndex()) {
                 prev_clip_id_other_playlist = j;
                 break;
             }
         }
         if (prev_clip_id_other_playlist >= 0) {
             in_blank = std::max(in_blank, clips[(size_t)prev_clip_id_other_playlist].first +
                                               m_allClips[clips[(size_t)prev_clip_id_other_playlist].second]->getPlaytime());
         }
 
         // the next clip on the other playlist might restrict the blank in/out
         int next_clip_id_other_playlist = -1;
         for (int j = (int)i + 1; j < (int)clips.size(); ++j) {
             if (other_playlist == m_allClips[clips[(size_t)j].second]->getSubPlaylistIndex()) {
                 next_clip_id_other_playlist = j;
                 break;
             }
         }
         if (next_clip_id_other_playlist >= 0) {
             out_blank = std::min(out_blank, clips[(size_t)next_clip_id_other_playlist].first - 1);
         }
         if (in_blank <= out_blank && !check_blank_zone(other_playlist, in_blank, out_blank)) {
             qDebug() << "ERROR: we expected blank on playlist " << other_playlist << " between " << in_blank << " and " << out_blank;
             return false;
         }
 
         last_out = clips[i].first + cur_clip->getPlaytime();
     }
     int playtime = std::max(m_playlists[0].get_playtime(), m_playlists[1].get_playtime());
     if (!clips.empty() && playtime != clips.back().first + m_allClips[clips.back().second]->getPlaytime()) {
         qDebug() << "Error: playtime is " << playtime << " but was expected to be" << clips.back().first + m_allClips[clips.back().second]->getPlaytime();
         return false;
     }
 
     // We now check compositions positions
     if (m_allCompositions.size() != m_compoPos.size()) {
         qDebug() << "Error: the number of compositions position doesn't match number of compositions";
         return false;
     }
     for (const auto &compo : m_allCompositions) {
         int pos = compo.second->getPosition();
         if (m_compoPos.count(pos) == 0) {
             qDebug() << "Error: the position of composition " << compo.first << " is not properly stored";
             return false;
         }
         if (m_compoPos[pos] != compo.first) {
             qDebug() << "Error: found composition" << m_compoPos[pos] << "instead of " << compo.first << "at position" << pos;
             return false;
         }
     }
     for (auto it = m_compoPos.begin(); it != m_compoPos.end(); ++it) {
         int compoId = it->second;
         int cur_in = m_allCompositions[compoId]->getPosition();
         Q_ASSERT(cur_in == it->first);
         int cur_out = cur_in + m_allCompositions[compoId]->getPlaytime() - 1;
         ++it;
         if (it != m_compoPos.end()) {
             int next_compoId = it->second;
             int next_in = m_allCompositions[next_compoId]->getPosition();
             int next_out = next_in + m_allCompositions[next_compoId]->getPlaytime() - 1;
             if (next_in <= cur_out) {
                 qDebug() << "Error: found collision between composition " << compoId << "[ " << cur_in << ", " << cur_out << "] and " << next_compoId << "[ "
                          << next_in << ", " << next_out << "]";
                 return false;
             }
         }
         --it;
     }
     return true;
 }
 
 std::pair<int, int> TrackModel::getClipIndexAt(int position)
 {
     READ_LOCK();
     for (int j = 0; j < 2; j++) {
         if (!m_playlists[j].is_blank_at(position)) {
             return {j, m_playlists[j].get_clip_index_at(position)};
         }
     }
     Q_ASSERT(false);
     return {-1, -1};
 }
 
+bool TrackModel::isLastClip(int position)
+{
+    READ_LOCK();
+    for (int j = 0; j < 2; j++) {
+        if (!m_playlists[j].is_blank_at(position)) {
+            return m_playlists[j].get_clip_index_at(position) == m_playlists[j].count() - 1;
+        }
+    }
+    return false;
+}
+
 bool TrackModel::isBlankAt(int position)
 {
     READ_LOCK();
     return m_playlists[0].is_blank_at(position) && m_playlists[1].is_blank_at(position);
 }
 
 int TrackModel::getBlankStart(int position)
 {
     READ_LOCK();
     int result = 0;
     for (auto &m_playlist : m_playlists) {
         if (m_playlist.count() == 0) {
             break;
         }
         if (!m_playlist.is_blank_at(position)) {
             result = position;
             break;
         }
         int clip_index = m_playlist.get_clip_index_at(position);
         int start = m_playlist.clip_start(clip_index);
         if (start > result) {
             result = start;
         }
     }
     return result;
 }
 
 int TrackModel::getBlankEnd(int position, int track)
 {
     READ_LOCK();
     // Q_ASSERT(m_playlists[track].is_blank_at(position));
     if (!m_playlists[track].is_blank_at(position)) {
         return position;
     }
     int clip_index = m_playlists[track].get_clip_index_at(position);
     int count = m_playlists[track].count();
     if (clip_index < count) {
         int blank_start = m_playlists[track].clip_start(clip_index);
         int blank_length = m_playlists[track].clip_length(clip_index);
         return blank_start + blank_length;
     }
     return INT_MAX;
 }
 
 int TrackModel::getBlankEnd(int position)
 {
     READ_LOCK();
     int end = INT_MAX;
     for (int j = 0; j < 2; j++) {
         end = std::min(getBlankEnd(position, j), end);
     }
     return end;
 }
 
 Fun TrackModel::requestCompositionResize_lambda(int compoId, int in, int out, bool logUndo)
 {
     QWriteLocker locker(&m_lock);
     int compo_position = m_allCompositions[compoId]->getPosition();
     Q_ASSERT(m_compoPos.count(compo_position) > 0);
     Q_ASSERT(m_compoPos[compo_position] == compoId);
     int old_in = compo_position;
     int old_out = old_in + m_allCompositions[compoId]->getPlaytime() - 1;
     qDebug() << "compo resize " << compoId << in << "-" << out << " / " << old_in << "-" << old_out;
     if (out == -1) {
         out = in + old_out - old_in;
     }
 
     auto update_snaps = [old_in, old_out, logUndo, this](int new_in, int new_out) {
         if (auto ptr = m_parent.lock()) {
             ptr->m_snaps->removePoint(old_in);
             ptr->m_snaps->removePoint(old_out + 1);
             ptr->m_snaps->addPoint(new_in);
             ptr->m_snaps->addPoint(new_out);
             ptr->checkRefresh(old_in, old_out);
             ptr->checkRefresh(new_in, new_out);
             if (logUndo) {
                 ptr->invalidateZone(old_in, old_out);
                 ptr->invalidateZone(new_in, new_out);
             }
             // ptr->adjustAssetRange(compoId, new_in, new_out);
         } else {
             qDebug() << "Error : Composition resize failed because parent timeline is not available anymore";
             Q_ASSERT(false);
         }
     };
 
     if (in == compo_position && (out == -1 || out == old_out)) {
         return []() {
             qDebug() << "//// NO MOVE PERFORMED\n!!!!!!!!!!!!!!!!!!!!!!!!!!";
             return true;
         };
     }
 
     // temporary remove of current compo to check collisions
     qDebug() << "// CURRENT COMPOSITIONS ----\n" << m_compoPos << "\n--------------";
     m_compoPos.erase(compo_position);
     bool intersecting = hasIntersectingComposition(in, out);
     // put it back
     m_compoPos[compo_position] = compoId;
 
     if (intersecting) {
         return []() {
             qDebug() << "//// FALSE MOVE PERFORMED\n!!!!!!!!!!!!!!!!!!!!!!!!!!";
             return false;
         };
     }
 
     return [in, out, compoId, update_snaps, this]() {
         if (isLocked()) return false;
         m_compoPos.erase(m_allCompositions[compoId]->getPosition());
         m_allCompositions[compoId]->setInOut(in, out);
         update_snaps(in, out + 1);
         m_compoPos[m_allCompositions[compoId]->getPosition()] = compoId;
         return true;
     };
 }
 
 bool TrackModel::requestCompositionInsertion(int compoId, int position, bool updateView, bool finalMove, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     if (isLocked()) {
         return false;
     }
     auto operation = requestCompositionInsertion_lambda(compoId, position, updateView, finalMove);
     if (operation()) {
         auto reverse = requestCompositionDeletion_lambda(compoId, updateView, finalMove);
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 bool TrackModel::requestCompositionDeletion(int compoId, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool finalDeletion)
 {
     QWriteLocker locker(&m_lock);
     if (isLocked()) {
         return false;
     }
     Q_ASSERT(m_allCompositions.count(compoId) > 0);
     auto old_composition = m_allCompositions[compoId];
     int old_position = old_composition->getPosition();
     Q_ASSERT(m_compoPos.count(old_position) > 0);
     Q_ASSERT(m_compoPos[old_position] == compoId);
     if (finalDeletion) {
         m_allCompositions[compoId]->selected = false;
     }
     auto operation = requestCompositionDeletion_lambda(compoId, updateView, finalMove);
     if (operation()) {
         auto reverse = requestCompositionInsertion_lambda(compoId, old_position, updateView, finalMove);
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 Fun TrackModel::requestCompositionDeletion_lambda(int compoId, bool updateView, bool finalMove)
 {
     QWriteLocker locker(&m_lock);
     // Find index of clip
     int clip_position = m_allCompositions[compoId]->getPosition();
     int old_in = clip_position;
     int old_out = old_in + m_allCompositions[compoId]->getPlaytime();
     return [compoId, old_in, old_out, updateView, finalMove, this]() {
         if (isLocked()) return false;
         int old_clip_index = getRowfromComposition(compoId);
         auto ptr = m_parent.lock();
         if (updateView) {
             ptr->_beginRemoveRows(ptr->makeTrackIndexFromID(getId()), old_clip_index, old_clip_index);
             ptr->_endRemoveRows();
         }
         m_allCompositions[compoId]->setCurrentTrackId(-1);
         m_allCompositions.erase(compoId);
         m_compoPos.erase(old_in);
         ptr->m_snaps->removePoint(old_in);
         ptr->m_snaps->removePoint(old_out);
         if (finalMove) {
             ptr->invalidateZone(old_in, old_out);
         }
         return true;
     };
 }
 
 int TrackModel::getCompositionByRow(int row) const
 {
     READ_LOCK();
     if (row < (int)m_allClips.size()) {
         return -1;
     }
     Q_ASSERT(row <= (int)m_allClips.size() + (int)m_allCompositions.size());
     auto it = m_allCompositions.cbegin();
     std::advance(it, row - (int)m_allClips.size());
     return (*it).first;
 }
 
 int TrackModel::getCompositionsCount() const
 {
     READ_LOCK();
     return (int)m_allCompositions.size();
 }
 
 Fun TrackModel::requestCompositionInsertion_lambda(int compoId, int position, bool updateView, bool finalMove)
 {
     QWriteLocker locker(&m_lock);
     bool intersecting = true;
     if (auto ptr = m_parent.lock()) {
         intersecting = hasIntersectingComposition(position, position + ptr->getCompositionPlaytime(compoId) - 1);
     } else {
         qDebug() << "Error : Composition Insertion failed because timeline is not available anymore";
     }
     if (!intersecting) {
         return [compoId, this, position, updateView, finalMove]() {
             if (isLocked()) return false;
             if (auto ptr = m_parent.lock()) {
                 std::shared_ptr<CompositionModel> composition = ptr->getCompositionPtr(compoId);
                 m_allCompositions[composition->getId()] = composition; // store clip
                 // update clip position and track
                 composition->setCurrentTrackId(getId());
                 int new_in = position;
                 int new_out = new_in + composition->getPlaytime();
                 composition->setInOut(new_in, new_out - 1);
                 if (updateView) {
                     int composition_index = getRowfromComposition(composition->getId());
                     ptr->_beginInsertRows(ptr->makeTrackIndexFromID(composition->getCurrentTrackId()), composition_index, composition_index);
                     ptr->_endInsertRows();
                 }
                 ptr->m_snaps->addPoint(new_in);
                 ptr->m_snaps->addPoint(new_out);
                 m_compoPos[new_in] = composition->getId();
                 if (finalMove) {
                     ptr->invalidateZone(new_in, new_out);
                 }
                 return true;
             }
             qDebug() << "Error : Composition Insertion failed because timeline is not available anymore";
             return false;
         };
     }
     return []() { return false; };
 }
 
 bool TrackModel::hasIntersectingComposition(int in, int out) const
 {
     READ_LOCK();
     auto it = m_compoPos.lower_bound(in);
     if (m_compoPos.empty()) {
         return false;
     }
     if (it != m_compoPos.end() && it->first <= out) {
         // compo at it intersects
         return true;
     }
     if (it == m_compoPos.begin()) {
         return false;
     }
     --it;
     int end = it->first + m_allCompositions.at(it->second)->getPlaytime() - 1;
     return end >= in;
 
     return false;
 }
 
 bool TrackModel::addEffect(const QString &effectId)
 {
     READ_LOCK();
     return m_effectStack->appendEffect(effectId);
 }
 
 const QString TrackModel::effectNames() const
 {
     READ_LOCK();
     return m_effectStack->effectNames();
 }
 
 bool TrackModel::stackEnabled() const
 {
     READ_LOCK();
     return m_effectStack->isStackEnabled();
 }
 
 void TrackModel::setEffectStackEnabled(bool enable)
 {
     m_effectStack->setEffectStackEnabled(enable);
 }
 
-int TrackModel::trackDuration()
+int TrackModel::trackDuration() const
 {
     return m_track->get_length();
 }
 
 bool TrackModel::isLocked() const
 {
     READ_LOCK();
     return m_track->get_int("kdenlive:locked_track");
 }
 
 bool TrackModel::isTimelineActive() const
 {
     READ_LOCK();
     return m_track->get_int("kdenlive:timeline_active");
 }
 
 bool TrackModel::shouldReceiveTimelineOp() const
 {
     READ_LOCK();
     return isTimelineActive() && !isLocked();
 }
 
 bool TrackModel::isAudioTrack() const
 {
     return m_track->get_int("kdenlive:audio_track") == 1;
 }
 
 PlaylistState::ClipState TrackModel::trackType() const
 {
     return (m_track->get_int("kdenlive:audio_track") == 1 ? PlaylistState::AudioOnly : PlaylistState::VideoOnly);
 }
 
 bool TrackModel::isHidden() const
 {
     return m_track->get_int("hide") & 1;
 }
 
 bool TrackModel::isMute() const
 {
     return m_track->get_int("hide") & 2;
 }
 
 bool TrackModel::importEffects(std::weak_ptr<Mlt::Service> service)
 {
     QWriteLocker locker(&m_lock);
     m_effectStack->importEffects(std::move(service), trackType());
     return true;
 }
 
 bool TrackModel::copyEffect(const std::shared_ptr<EffectStackModel> &stackModel, int rowId)
 {
     QWriteLocker locker(&m_lock);
     return m_effectStack->copyEffect(stackModel->getEffectStackRow(rowId), isAudioTrack() ? PlaylistState::AudioOnly : PlaylistState::VideoOnly);
 }
 
 void TrackModel::lock()
 {
     setProperty(QStringLiteral("kdenlive:locked_track"), QStringLiteral("1"));
     if (auto ptr = m_parent.lock()) {
         QModelIndex ix = ptr->makeTrackIndexFromID(m_id);
         ptr->dataChanged(ix, ix, {TimelineModel::IsLockedRole});
     }
 }
 void TrackModel::unlock()
 {
     setProperty(QStringLiteral("kdenlive:locked_track"), (char *)nullptr);
     if (auto ptr = m_parent.lock()) {
         QModelIndex ix = ptr->makeTrackIndexFromID(m_id);
         ptr->dataChanged(ix, ix, {TimelineModel::IsLockedRole});
     }
 }
diff --git a/src/timeline2/model/trackmodel.hpp b/src/timeline2/model/trackmodel.hpp
index 7f4a3315f..3153d063a 100644
--- a/src/timeline2/model/trackmodel.hpp
+++ b/src/timeline2/model/trackmodel.hpp
@@ -1,290 +1,294 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Nicolas Carion                                  *
  *   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/>. *
  ***************************************************************************/
 
 #ifndef TRACKMODEL_H
 #define TRACKMODEL_H
 
 #include "definitions.h"
 #include "undohelper.hpp"
 #include <QReadWriteLock>
 #include <QSharedPointer>
 #include <memory>
 #include <mlt++/MltPlaylist.h>
 #include <mlt++/MltTractor.h>
 #include <unordered_map>
 #include <unordered_set>
 
 class TimelineModel;
 class ClipModel;
 class CompositionModel;
 class EffectStackModel;
 
 /* @brief This class represents a Track object, as viewed by the backend.
    To allow same track transitions, a Track object corresponds to two Mlt::Playlist, between which we can switch when required by the transitions.
    In general, the Gui associated with it will send modification queries (such as resize or move), and this class authorize them or not depending on the
    validity of the modifications
 */
 class TrackModel
 {
 
 public:
     TrackModel() = delete;
     ~TrackModel();
 
     friend class ClipModel;
     friend class CompositionModel;
     friend class TimelineController;
     friend struct TimelineFunctions;
     friend class TimelineItemModel;
     friend class TimelineModel;
 
 private:
     /* This constructor is private, call the static construct instead */
     TrackModel(const std::weak_ptr<TimelineModel> &parent, int id = -1, const QString &trackName = QString(), bool audioTrack = false);
     TrackModel(const std::weak_ptr<TimelineModel> &parent, Mlt::Tractor mltTrack, int id = -1);
 
 public:
     /* @brief Creates a track, which references itself to the parent
        Returns the (unique) id of the created track
        @param id Requested id of the track. Automatic if id = -1
        @param pos is the optional position of the track. If left to -1, it will be added at the end
      */
     static int construct(const std::weak_ptr<TimelineModel> &parent, int id = -1, int pos = -1, const QString &trackName = QString(), bool audioTrack = false);
 
     /* @brief returns the number of clips */
     int getClipsCount();
 
     /* @brief returns the number of compositions */
     int getCompositionsCount() const;
 
     /* Perform a split at the requested position */
     bool splitClip(QSharedPointer<ClipModel> caller, int position);
 
     /* Implicit conversion operator to access the underlying producer
      */
     operator Mlt::Producer &() { return *m_track.get(); }
 
     /* @brief Returns true if track is in locked state
      */
     bool isLocked() const;
     /* @brief Returns true if track is active in timeline, ie.
      * will receive insert/lift/overwrite/extract operations
      */
     bool isTimelineActive() const;
     /* @brief Returns true if track is active and not locked
      */
     bool shouldReceiveTimelineOp() const;
     /* @brief Returns true if track is an audio track
      */
     bool isAudioTrack() const;
     /* @brief Returns the track type (audio / video)
      */
     PlaylistState::ClipState trackType() const;
     /* @brief Returns true if track is disabled
      */
     bool isHidden() const;
     /* @brief Returns true if track is disabled
      */
     bool isMute() const;
 
     // TODO make protected
     QVariant getProperty(const QString &name) const;
     void setProperty(const QString &name, const QString &value);
 
 protected:
     /* @brief This will lock the track: it will no longer allow insertion/deletion/resize of items
        This functions are dangerous to call directly since locking the track will potentially
        mess up with the undo/redo system (a track lock may make an undo impossible).
        Prefer calling TimelineModel::setTrackLockedState */
     void lock();
     void unlock();
 
     /* @brief Returns a lambda that performs a resize of the given clip.
        The lamda returns true if the operation succeeded, and otherwise nothing is modified
        This method is protected because it shouldn't be called directly. Call the function in the timeline instead.
        @param clipId is the id of the clip
        @param in is the new starting on the clip
        @param out is the new ending on the clip
        @param right is true if we change the right side of the clip, false otherwise
     */
     Fun requestClipResize_lambda(int clipId, int in, int out, bool right);
 
     /* @brief Performs an insertion of the given clip.
        Returns true if the operation succeeded, and otherwise, the track is not modified.
        This method is protected because it shouldn't be called directly. Call the function in the timeline instead.
        @param clip is the id of the clip
        @param position is the position where to insert the clip
        @param updateView whether we send update to the view
        @param finalMove if the move is finished (not while dragging), so we invalidate timeline preview / check project duration
        @param undo Lambda function containing the current undo stack. Will be updated with current operation
        @param redo Lambda function containing the current redo queue. Will be updated with current operation
     */
     bool requestClipInsertion(int clipId, int position, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool groupMove = false);
     /* @brief This function returns a lambda that performs the requested operation */
     Fun requestClipInsertion_lambda(int clipId, int position, bool updateView, bool finalMove, bool groupMove = false);
 
     /* @brief Performs an deletion of the given clip.
        Returns true if the operation succeeded, and otherwise, the track is not modified.
        This method is protected because it shouldn't be called directly. Call the function in the timeline instead.
        @param clipId is the id of the clip
        @param updateView whether we send update to the view
        @param finalMove if the move is finished (not while dragging), so we invalidate timeline preview / check project duration
        @param undo Lambda function containing the current undo stack. Will be updated with current operation
        @param redo Lambda function containing the current redo queue. Will be updated with current operation
        @param groupMove If true, this is part of a larger operation and some operations like checking track duration will not be performed and have to be performed separately
        @param finalDeletion If true, the clip will be deselected (should be false if this is a clip move doing delte/insert)
     */
     bool requestClipDeletion(int clipId, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool groupMove, bool finalDeletion);
     /* @brief This function returns a lambda that performs the requested operation */
     Fun requestClipDeletion_lambda(int clipId, bool updateView, bool finalMove, bool groupMove);
 
     /* @brief Performs an insertion of the given composition.
        Returns true if the operation succeeded, and otherwise, the track is not modified.
        This method is protected because it shouldn't be called directly. Call the function in the timeline instead.
        Note that in Mlt, the composition insertion logic is not really at the track level, but we use that level to do collision checking
        @param compoId is the id of the composition
        @param position is the position where to insert the composition
        @param updateView whether we send update to the view
        @param undo Lambda function containing the current undo stack. Will be updated with current operation
        @param redo Lambda function containing the current redo queue. Will be updated with current operation
     */
     bool requestCompositionInsertion(int compoId, int position, bool updateView, bool finalMove, Fun &undo, Fun &redo);
     /* @brief This function returns a lambda that performs the requested operation */
     Fun requestCompositionInsertion_lambda(int compoId, int position, bool updateView, bool finalMove = false);
 
     bool requestCompositionDeletion(int compoId, bool updateView, bool finalMove, Fun &undo, Fun &redo, bool finalDeletion);
     Fun requestCompositionDeletion_lambda(int compoId, bool updateView, bool finalMove = false);
     Fun requestCompositionResize_lambda(int compoId, int in, int out = -1, bool logUndo = false);
 
     /* @brief Returns the size of the blank before or after the given clip
        @param clipId is the id of the clip
        @param after is true if we query the blank after, false otherwise
     */
     int getBlankSizeNearClip(int clipId, bool after);
     int getBlankSizeNearComposition(int compoId, bool after);
     int getBlankStart(int position);
     int getBlankSizeAtPos(int frame);
+    /* @brief Returns true if clip at position is the last on playlist
+     * @param position the position in playlist
+    */
+    bool isLastClip(int position);
 
     /*@brief Returns the best composition duration depending on clips on the track */
     int suggestCompositionLength(int position);
 
     /*@brief Returns the (unique) construction id of the track*/
     int getId() const;
 
     /*@brief This function is used only by the QAbstractItemModel
       Given a row in the model, retrieves the corresponding clip id. If it does not exist, returns -1
     */
     int getClipByRow(int row) const;
 
     /*@brief This function is used only by the QAbstractItemModel
       Given a row in the model, retrieves the corresponding composition id. If it does not exist, returns -1
     */
     int getCompositionByRow(int row) const;
     /*@brief This function is used only by the QAbstractItemModel
       Given a clip ID, returns the row of the clip.
     */
     int getRowfromClip(int clipId) const;
 
     /*@brief This function is used only by the QAbstractItemModel
       Given a composition ID, returns the row of the composition.
     */
     int getRowfromComposition(int compoId) const;
 
     /*@brief This is an helper function that test frame level consistency with the MLT structures */
     bool checkConsistency();
 
     /* @brief Returns true if we have a composition intersecting with the range [in,out]*/
     bool hasIntersectingComposition(int in, int out) const;
 
     /* @brief This is an helper function that returns the sub-playlist in which the clip is inserted, along with its index in the playlist
      @param position the position of the target clip*/
     std::pair<int, int> getClipIndexAt(int position);
     QSharedPointer<Mlt::Producer> getClipProducer(int clipId);
 
     /* @brief This is an helper function that checks in all playlists if the given position is a blank */
     bool isBlankAt(int position);
 
     /* @brief This is an helper function that returns the end of the blank that covers given position */
     int getBlankEnd(int position);
     /* Same, but we restrict to a specific track*/
     int getBlankEnd(int position, int track);
 
     /* @brief Returns the clip id on this track at position requested, or -1 if no clip */
     int getClipByPosition(int position);
 
     /* @brief Returns the composition id on this track starting position requested, or -1 if not found */
     int getCompositionByPosition(int position);
     /* @brief Add a track effect */
     bool addEffect(const QString &effectId);
 
     /* @brief Returns a comma separated list of effect names */
     const QString effectNames() const;
 
     /* @brief Returns true if effect stack is enabled */
     bool stackEnabled() const;
 
     /* @brief Enable / disable the track's effect stack */
     void setEffectStackEnabled(bool enable);
 
     /* @brief This function removes the clip from the mlt object, and then insert it back in the same spot again.
      * This is used when some properties of the clip have changed, and we need this to refresh it */
     void replugClip(int clipId);
 
-    int trackDuration();
+    int trackDuration() const;
 
     /* @brief Returns the list of the ids of the clips that intersect the given range */
     std::unordered_set<int> getClipsInRange(int position, int end = -1);
     /* @brief Returns the list of the ids of the compositions that intersect the given range */
     std::unordered_set<int> getCompositionsInRange(int position, int end);
 
     /* @brief Import effects from a service that contains some (another track) */
     bool importEffects(std::weak_ptr<Mlt::Service> service);
     /* @brief Copy effects from anoter effect stack */
     bool copyEffect(const std::shared_ptr<EffectStackModel> &stackModel, int rowId);
 
 public slots:
     /*Delete the current track and all its associated clips */
     void slotDelete();
 
 private:
     std::weak_ptr<TimelineModel> m_parent;
     int m_id; // this is the creation id of the track, used for book-keeping
 
     // We fake two playlists to allow same track transitions.
     std::shared_ptr<Mlt::Tractor> m_track;
     Mlt::Playlist m_playlists[2];
 
     std::map<int, std::shared_ptr<ClipModel>> m_allClips; /*this is important to keep an
                                                                             ordered structure to store the clips, since we use their ids order as row order*/
     std::map<int, std::shared_ptr<CompositionModel>>
         m_allCompositions; /*this is important to keep an
                                    ordered structure to store the clips, since we use their ids order as row order*/
 
     std::map<int, int> m_compoPos; // We store the positions of the compositions. In Melt, the compositions are not inserted at the track level, but we keep
                                    // those positions here to check for moves and resize
 
     mutable QReadWriteLock m_lock; // This is a lock that ensures safety in case of concurrent access
 
 protected:
     std::shared_ptr<EffectStackModel> m_effectStack;
 };
 
 #endif