diff --git a/src/timeline2/model/clipmodel.cpp b/src/timeline2/model/clipmodel.cpp
index 42e1a583f..17ba35ec4 100644
--- a/src/timeline2/model/clipmodel.cpp
+++ b/src/timeline2/model/clipmodel.cpp
@@ -1,826 +1,826 @@
 /***************************************************************************
  *   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;
     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;
             }
             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()) {
                     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 = int(double(oldDuration) * std::abs(previousSpeed / speed) + 0.5);
     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();
         int duration = out - in;
-        in = qMax(0, (int)(m_producer->get_length() * std::fabs(m_speed) - out - 1));
-        out = in + duration;
+        in = qMax(0, (int)((m_producer->get_length() * std::fabs(m_speed/speed)) - 1 - (out * std::fabs(m_speed/speed))));
+        out = in + newDuration;
         operation = [operation, in, out, this]() {
             bool res = operation();
             if (res) {
                 setInOut(in, out);
             }
             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) {
             bool res = requestResize(qMin(newDuration, getMaxDuration()), true, local_undo, local_redo, true);
             if (!res) {
                 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/view/qml/ClipThumbs.qml b/src/timeline2/view/qml/ClipThumbs.qml
index 8dff22d95..011e83823 100644
--- a/src/timeline2/view/qml/ClipThumbs.qml
+++ b/src/timeline2/view/qml/ClipThumbs.qml
@@ -1,44 +1,47 @@
 import QtQuick 2.6
 import QtQuick.Controls 2.2
 import QtQml.Models 2.2
 import com.enums 1.0
 
 
 Row {
     id: thumbRow
     anchors.fill: parent
     visible: !isAudio
     opacity: parentTrack.isAudio || parentTrack.isHidden || clipStatus == ClipState.Disabled ? 0.2 : 1
     property int thumbWidth: container.height * 16.0/9.0
     property int scrollStart: scrollView.flickableItem.contentX - clipRoot.modelStart * timeline.scaleFactor
     property int scrollEnd: scrollStart + scrollView.viewport.width
     property bool enableCache: clipRoot.itemType == ProducerType.Video || clipRoot.itemType == ProducerType.AV
 
     function reload() {
         clipRoot.baseThumbPath =''
         clipRoot.baseThumbPath = clipRoot.variableThumbs ? '' : 'image://thumbnail/' + clipRoot.binId + '/' + (clipRoot.isImage ? '#0' : '#')
     }
 
     Repeater {
         id: thumbRepeater
         // switching the model allows to have different view modes:
         // 2: will display start / end thumbs
         // container.width / thumbRow.thumbWidth will display all frames showThumbnails
         // 1: only show first thumbnail
         // 0: will disable thumbnails
         model: parentTrack.trackThumbsFormat == 0 ? 2 : parentTrack.trackThumbsFormat == 1 ? Math.ceil(container.width / thumbRow.thumbWidth) : parentTrack.trackThumbsFormat == 2 ? 1 : 0
         property int startFrame: clipRoot.inPoint
         property int endFrame: clipRoot.outPoint
         property real imageWidth: Math.max(thumbRow.thumbWidth, container.width / thumbRepeater.count)
+        property int thumbStartFrame: (clipRoot.speed >= 0) ? Math.round(clipRoot.inPoint * clipRoot.speed) : Math.round((clipRoot.maxDuration - clipRoot.inPoint) * -clipRoot.speed - 1)
+        property int thumbEndFrame: (clipRoot.speed >= 0) ? Math.round(clipRoot.outPoint * clipRoot.speed) : Math.round((clipRoot.maxDuration - clipRoot.outPoint) * -clipRoot.speed - 1)
+
         Image {
             width: thumbRepeater.imageWidth
             height: container.height
             fillMode: Image.PreserveAspectFit
             asynchronous: true
             cache: enableCache
             property int currentFrame: Math.floor(clipRoot.inPoint + Math.round((index) * width / timeline.scaleFactor)* clipRoot.speed)
             horizontalAlignment: thumbRepeater.count < 3 ? (index == 0 ? Image.AlignLeft : Image.AlignRight) : Image.AlignLeft
-            source: thumbRepeater.count < 3 ? (index == 0 ? clipRoot.baseThumbPath + Math.floor(clipRoot.inPoint * clipRoot.speed) : clipRoot.baseThumbPath + Math.floor(clipRoot.outPoint * clipRoot.speed)) : (index * width < thumbRow.scrollStart - width || index * width > thumbRow.scrollEnd) ? '' : clipRoot.baseThumbPath + currentFrame
+            source: thumbRepeater.count < 3 ? (index == 0 ? clipRoot.baseThumbPath + thumbRepeater.thumbStartFrame : clipRoot.baseThumbPath + thumbRepeater.thumbEndFrame) : (index * width < thumbRow.scrollStart - width || index * width > thumbRow.scrollEnd) ? '' : clipRoot.baseThumbPath + currentFrame
         }
     }
 }