diff --git a/libs/ui/kis_animation_exporter.cpp b/libs/ui/kis_animation_exporter.cpp
index 72cdbb4cd1..3d536e0cda 100644
--- a/libs/ui/kis_animation_exporter.cpp
+++ b/libs/ui/kis_animation_exporter.cpp
@@ -1,378 +1,378 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  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) any later version.
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_exporter.h"
 
 #include <QDesktopServices>
 #include <QProgressDialog>
 #include <KisMimeDatabase.h>
 #include <QEventLoop>
 #include <QMessageBox>
 
 #include "KoFileDialog.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "KisImportExportManager.h"
 #include "kis_image_animation_interface.h"
 #include "KisPart.h"
 #include "KisMainWindow.h"
 
 #include "kis_paint_layer.h"
 #include "kis_group_layer.h"
 #include "kis_time_range.h"
 #include "kis_painter.h"
 
 #include "kis_image_lock_hijacker.h"
 
 
 struct KisAnimationExporterUI::Private
 {
     QWidget *parentWidget;
     KisAnimationExportSaver *exporter;
 
     Private(QWidget *parent)
         : parentWidget(parent),
           exporter(0)
     {}
 };
 
 KisAnimationExporterUI::KisAnimationExporterUI(QWidget *parent)
     : m_d(new Private(parent))
 {
 }
 
 KisAnimationExporterUI::~KisAnimationExporterUI()
 {
     if (m_d->exporter) {
         delete m_d->exporter;
     }
 }
 
 struct KisAnimationExporter::Private
 {
     Private(KisDocument *document, int fromTime, int toTime)
         : document(document)
         , image(document->image())
         , firstFrame(fromTime)
         , lastFrame(toTime)
         , currentFrame(-1)
         , batchMode(document->fileBatchMode())
         , isCancelled(false)
         , status(KisImportExportFilter::OK)
         , tmpDevice(new KisPaintDevice(image->colorSpace()))
     {
     }
 
     KisDocument *document;
     KisImageWSP image;
 
     int firstFrame;
     int lastFrame;
     int currentFrame;
 
     bool batchMode;
     bool isCancelled;
 
     KisImportExportFilter::ConversionStatus status;
 
     SaveFrameCallback saveFrameCallback;
 
     KisPaintDeviceSP tmpDevice;
 
     KisPropertiesConfigurationSP exportConfiguration;
     QProgressDialog progress;
 
 };
 
 KisAnimationExporter::KisAnimationExporter(KisDocument *document, int fromTime, int toTime)
     : m_d(new Private(document, fromTime, toTime))
 {
     connect(m_d->image->animationInterface(), SIGNAL(sigFrameReady(int)),
             this, SLOT(frameReadyToCopy(int)), Qt::DirectConnection);
 
     connect(this, SIGNAL(sigFrameReadyToSave()),
             this, SLOT(frameReadyToSave()), Qt::QueuedConnection);
 }
 
 KisAnimationExporter::~KisAnimationExporter()
 {
 }
 
 void KisAnimationExporter::setExportConfiguration(KisPropertiesConfigurationSP exportConfiguration)
 {
     m_d->exportConfiguration = exportConfiguration;
 }
 
 void KisAnimationExporter::setSaveFrameCallback(SaveFrameCallback func)
 {
     m_d->saveFrameCallback = func;
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExporter::exportAnimation()
 {
 
     if (!m_d->batchMode) {
         QString message = i18n("Preparing to export frames...");
 
         m_d->progress.reset();
         m_d->progress.setLabelText(message);
         m_d->progress.setWindowModality(Qt::ApplicationModal);
         m_d->progress.setCancelButton(0);
         m_d->progress.setMinimumDuration(0);
         m_d->progress.setValue(0);
         m_d->progress.setMinimum(0);
         m_d->progress.setMaximum(100);
 
         emit m_d->document->statusBarMessage(message);
         emit m_d->document->sigProgress(0);
         connect(m_d->document, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
     }
 
     /**
      * HACK ALERT: Here we remove the image lock! We do it in a GUI
      *             thread under the barrier lock held, so it is
      *             guaranteed no other stroke will accidentally be
      *             started by this. And showing an app-modal dialog to
      *             the user will prevent him from doing anything
      *             nasty.
      */
     KisImageLockHijacker badGuy(m_d->image);
     Q_UNUSED(badGuy);
 
     KIS_ASSERT_RECOVER(!m_d->image->locked()) { return KisImportExportFilter::InternalError; }
 
     m_d->status = KisImportExportFilter::OK;
     m_d->currentFrame = m_d->firstFrame;
     m_d->image->animationInterface()->requestFrameRegeneration(m_d->currentFrame, m_d->image->bounds());
 
     QEventLoop loop;
     loop.connect(this, SIGNAL(sigFinished()), SLOT(quit()));
     loop.exec();
 
     if (!m_d->batchMode) {
         disconnect(m_d->document, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
         emit m_d->document->sigProgress(100);
         emit m_d->document->clearStatusBarMessage();
         m_d->progress.reset();
     }
 
     return m_d->status;
 }
 
 void KisAnimationExporter::cancel()
 {
     m_d->isCancelled = true;
 }
 
 void KisAnimationExporter::frameReadyToCopy(int time)
 {
     if (time != m_d->currentFrame) return;
 
     QRect rc = m_d->image->bounds();
     KisPainter::copyAreaOptimized(rc.topLeft(), m_d->image->projection(), m_d->tmpDevice, rc);
 
     emit sigFrameReadyToSave();
 }
 
 void KisAnimationExporter::frameReadyToSave()
 {
     KIS_ASSERT_RECOVER(m_d->saveFrameCallback) {
         m_d->status = KisImportExportFilter::InternalError;
         emit sigFinished();
         return;
     }
 
     if (m_d->isCancelled) {
         m_d->status = KisImportExportFilter::UserCancelled;
         emit sigFinished();
         return;
     }
 
     KisImportExportFilter::ConversionStatus result =
         KisImportExportFilter::OK;
     int time = m_d->currentFrame;
 
     result = m_d->saveFrameCallback(time, m_d->tmpDevice, m_d->exportConfiguration);
 
     if (!m_d->batchMode) {
         emit m_d->document->sigProgress((time - m_d->firstFrame) * 100 /
                                         (m_d->lastFrame - m_d->firstFrame));
     }
 
     qDebug() << result << time << m_d->lastFrame;
 
     QString dialogText = QString("Exporting Frame ").append(QString::number(time)).append(" of ").append(QString::number(m_d->lastFrame));
     int percentageProcessed = (float(time) / float(m_d->lastFrame) * 100);
 
     m_d->progress.setLabelText(dialogText);
     m_d->progress.setValue(int(percentageProcessed));
 
     if (result == KisImportExportFilter::OK && time < m_d->lastFrame) {
         m_d->currentFrame = time + 1;
         m_d->image->animationInterface()->requestFrameRegeneration(m_d->currentFrame, m_d->image->bounds());
     } else {
         emit sigFinished();
     }
 }
 
 struct KisAnimationExportSaver::Private
 {
     Private(KisDocument *document, int fromTime, int toTime, int _sequenceNumberingOffset)
         : document(document)
         , image(document->image())
         , firstFrame(fromTime)
         , lastFrame(toTime)
         , sequenceNumberingOffset(_sequenceNumberingOffset)
         , tmpDoc(KisPart::instance()->createDocument())
         , exporter(document, fromTime, toTime)
     {
         tmpDoc->setAutoSaveDelay(0);
 
         tmpImage = new KisImage(tmpDoc->createUndoStore(),
                                 image->bounds().width(),
                                 image->bounds().height(),
                                 image->colorSpace(),
                                 QString());
 
         tmpImage->setResolution(image->xRes(), image->yRes());
         tmpDoc->setCurrentImage(tmpImage);
 
         KisPaintLayer* paintLayer = new KisPaintLayer(tmpImage, "paint device", 255);
         tmpImage->addNode(paintLayer, tmpImage->rootLayer(), KisLayerSP(0));
 
         tmpDevice = paintLayer->paintDevice();
     }
 
     KisDocument *document;
     KisImageWSP image;
     int firstFrame;
     int lastFrame;
     int sequenceNumberingOffset;
 
     QScopedPointer<KisDocument> tmpDoc;
     KisImageSP tmpImage;
     KisPaintDeviceSP tmpDevice;
 
     KisAnimationExporter exporter;
 
     QString filenamePrefix;
     QString filenameSuffix;
 };
 
 KisAnimationExportSaver::KisAnimationExportSaver(KisDocument *document, const QString &baseFilename, int fromTime, int toTime, int sequenceNumberingOffset)
     : m_d(new Private(document, fromTime, toTime, sequenceNumberingOffset))
 {
     int baseLength = baseFilename.lastIndexOf(".");
     if (baseLength > -1) {
         m_d->filenamePrefix = baseFilename.left(baseLength);
         m_d->filenameSuffix = baseFilename.right(baseFilename.length() - baseLength);
     } else {
         m_d->filenamePrefix = baseFilename;
     }
 
     QString mimefilter = KisMimeDatabase::mimeTypeForFile(baseFilename);
     m_d->tmpDoc->setOutputMimeType(mimefilter.toLatin1());
     m_d->tmpDoc->setFileBatchMode(true);
 
     using namespace std::placeholders; // For _1 placeholder
     m_d->exporter.setSaveFrameCallback(std::bind(&KisAnimationExportSaver::saveFrameCallback, this, _1, _2, _3));
     
    
     
 }
 
 KisAnimationExportSaver::~KisAnimationExportSaver()
 {
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExportSaver::exportAnimation(KisPropertiesConfigurationSP cfg)
 {
     QFileInfo info(savedFilesMask());
 
     QDir dir(info.absolutePath());
     QStringList filesList = dir.entryList({ info.fileName() });
 
     if (!filesList.isEmpty()) {
         if (m_d->document->fileBatchMode()) {
             return KisImportExportFilter::CreationError;
         }
 
         QStringList truncatedList = filesList;
 
         while (truncatedList.size() > 3) {
             truncatedList.takeLast();
         }
 
         QString exampleFiles = truncatedList.join(", ");
         if (truncatedList.size() != filesList.size()) {
             exampleFiles += QString(", ...");
         }
 
         QMessageBox::StandardButton result =
                 QMessageBox::warning(0,
                                      i18n("Delete old frames?"),
                                      i18n("Frames with the same naming "
                                           "scheme exist in the destination "
                                           "directory. They are going to be "
                                           "deleted, continue?\n\n"
                                           "Directory: %1\n"
                                           "Files: %2",
                                           info.absolutePath(), exampleFiles),
                                      QMessageBox::Yes | QMessageBox::No,
                                      QMessageBox::No);
 
         if (result == QMessageBox::Yes) {
             Q_FOREACH (const QString &file, filesList) {
                 if (!dir.remove(file)) {
                     QMessageBox::critical(0,
                                           i18n("Failed to delete"),
                                           i18n("Failed to delete an old frame file:\n\n"
                                                "%1\n\n"
                                                "Rendering cancelled.", dir.absoluteFilePath(file)));
                     return KisImportExportFilter::CreationError;
                 }
             }
         } else {
             return KisImportExportFilter::UserCancelled;
         }
     }
 
     m_d->exporter.setExportConfiguration(cfg);
     return m_d->exporter.exportAnimation();
 }
 
 KisImportExportFilter::ConversionStatus KisAnimationExportSaver::saveFrameCallback(int time, KisPaintDeviceSP frame, KisPropertiesConfigurationSP exportConfiguration)
 {
     KisImportExportFilter::ConversionStatus status = KisImportExportFilter::OK;
 
     QString frameNumber = QString("%1").arg(time - m_d->firstFrame + m_d->sequenceNumberingOffset, 4, 10, QChar('0'));
     QString filename = m_d->filenamePrefix + frameNumber + m_d->filenameSuffix;
 
     QRect rc = m_d->image->bounds();
     KisPainter::copyAreaOptimized(rc.topLeft(), frame, m_d->tmpDevice, rc);
     if (!m_d->tmpDoc->exportDocument(QUrl::fromLocalFile(filename), exportConfiguration)) {
         status = KisImportExportFilter::InternalError;
     }
 
     return status;
 }
 
 QString KisAnimationExportSaver::savedFilesMask() const
 {
-    return m_d->filenamePrefix + "????" + m_d->filenameSuffix;
+    return m_d->filenamePrefix + "%04d" + m_d->filenameSuffix;
 }
diff --git a/plugins/impex/video/video_saver.cpp b/plugins/impex/video/video_saver.cpp
index 1ee24db8e6..c1d88794b5 100644
--- a/plugins/impex/video/video_saver.cpp
+++ b/plugins/impex/video/video_saver.cpp
@@ -1,330 +1,330 @@
 /*
  *  Copyright (c) 2016 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  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) any later version.
  *
  *  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, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "video_saver.h"
 
 #include <QDebug>
 
 #include <QFileInfo>
 
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoResourcePaths.h>
 
 
 #include <kis_image.h>
 #include <kis_image_animation_interface.h>
 #include <kis_time_range.h>
 
 #include "kis_config.h"
 #include "kis_animation_exporter.h"
 
 #include <QFileSystemWatcher>
 #include <QProcess>
 #include <QProgressDialog>
 #include <QEventLoop>
 #include <QTemporaryFile>
 #include <QTemporaryDir>
 #include <QTime>
 
 #include "KisPart.h"
 
 class KisFFMpegProgressWatcher : public QObject {
     Q_OBJECT
 public:
     KisFFMpegProgressWatcher(QFile &progressFile, int totalFrames)
         : m_progressFile(progressFile),
           m_totalFrames(totalFrames)
         {
             connect(&m_progressWatcher, SIGNAL(fileChanged(QString)), SLOT(slotFileChanged()));
 
 
             m_progressWatcher.addPath(m_progressFile.fileName());
         }
 
 private Q_SLOTS:
     void slotFileChanged() {
         int currentFrame = -1;
         bool isEnded = false;
 
         while(!m_progressFile.atEnd()) {
             QString line = QString(m_progressFile.readLine()).remove(QChar('\n'));
             QStringList var = line.split("=");
 
             if (var[0] == "frame") {
                 currentFrame = var[1].toInt();
             } else if (var[0] == "progress") {
                 isEnded = var[1] == "end";
             }
         }
 
         if (isEnded) {
             emit sigProgressChanged(100);
             emit sigProcessingFinished();
         } else {
 
             emit sigProgressChanged(100 * currentFrame / m_totalFrames);
         }
     }
 
 Q_SIGNALS:
     void sigProgressChanged(int percent);
     void sigProcessingFinished();
 
 private:
     QFileSystemWatcher m_progressWatcher;
     QFile &m_progressFile;
     int m_totalFrames;
 };
 
 
 class KisFFMpegRunner
 {
 public:
     KisFFMpegRunner(const QString &ffmpegPath)
         : m_cancelled(false),
           m_ffmpegPath(ffmpegPath) {}
 public:
     KisImageBuilder_Result runFFMpeg(const QStringList &specialArgs,
                                      const QString &actionName,
                                      const QString &logPath,
                                      int totalFrames)
     {
         dbgFile << "runFFMpeg: specialArgs" << specialArgs
                 << "actionName" << actionName
                 << "logPath" << logPath
                 << "totalFrames" << totalFrames;
 
         QTemporaryFile progressFile(QDir::tempPath() + QDir::separator() + "KritaFFmpegProgress.XXXXXX");
         progressFile.open();
 
         m_process.setStandardOutputFile(logPath);
         m_process.setProcessChannelMode(QProcess::MergedChannels);
         QStringList args;
         args << "-v" << "debug"
              << "-nostdin"
              << "-progress" << progressFile.fileName()
              << specialArgs;
 
         qDebug() << "\t" << m_ffmpegPath << args.join(" ");
 
         m_cancelled = false;
         m_process.start(m_ffmpegPath, args);
         return waitForFFMpegProcess(actionName, progressFile, m_process, totalFrames);
     }
 
     void cancel() {
         m_cancelled = true;
         m_process.kill();
     }
 
 private:
     KisImageBuilder_Result waitForFFMpegProcess(const QString &message,
                                                 QFile &progressFile,
                                                 QProcess &ffmpegProcess,
                                                 int totalFrames)
     {
 
         KisFFMpegProgressWatcher watcher(progressFile, totalFrames);
 
         QProgressDialog progress(message, "", 0, 0, KisPart::instance()->currentMainwindow());
         progress.setWindowModality(Qt::ApplicationModal);
         progress.setCancelButton(0);
         progress.setMinimumDuration(0);
         progress.setValue(0);
         progress.setRange(0, 100);
 
         QEventLoop loop;
         loop.connect(&watcher, SIGNAL(sigProcessingFinished()), SLOT(quit()));
         loop.connect(&ffmpegProcess, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(quit()));
         loop.connect(&watcher, SIGNAL(sigProgressChanged(int)), &progress, SLOT(setValue(int)));
         loop.exec();
 
         // wait for some errorneous case
         ffmpegProcess.waitForFinished(5000);
 
         KisImageBuilder_Result retval = KisImageBuilder_RESULT_OK;
 
         if (ffmpegProcess.state() != QProcess::NotRunning) {
             // sorry...
             ffmpegProcess.kill();
             retval = KisImageBuilder_RESULT_FAILURE;
         } else if (m_cancelled) {
             retval = KisImageBuilder_RESULT_CANCEL;
         } else if (ffmpegProcess.exitCode()) {
             retval = KisImageBuilder_RESULT_FAILURE;
         }
 
         return retval;
     }
 
 private:
     QProcess m_process;
     bool m_cancelled;
     QString m_ffmpegPath;
 };
 
 
 VideoSaver::VideoSaver(KisDocument *doc, const QString &ffmpegPath, bool batchMode)
     : m_image(doc->image())
     , m_doc(doc)
     , m_batchMode(batchMode)
     , m_ffmpegPath(ffmpegPath)
     , m_runner(new KisFFMpegRunner(ffmpegPath))
 {
 }
 
 VideoSaver::~VideoSaver()
 {
 }
 
 KisImageSP VideoSaver::image()
 {
     return m_image;
 }
 
 bool VideoSaver::hasFFMpeg() const
 {
     return !m_ffmpegPath.isEmpty();
 }
 
 KisImageBuilder_Result VideoSaver::encode(const QString &filename, KisPropertiesConfigurationSP configuration)
 {
 
     qDebug() << "ffmpeg" << m_ffmpegPath << "filename" << filename << "configuration" << configuration->toXML();
 
     if (m_ffmpegPath.isEmpty()) {
         m_ffmpegPath = configuration->getString("ffmpeg_path");
         if (!QFileInfo(m_ffmpegPath).exists()) {
             return KisImageBuilder_RESULT_FAILURE;
         }
     }
 
     KisImageBuilder_Result result = KisImageBuilder_RESULT_OK;
 
     KisImageAnimationInterface *animation = m_image->animationInterface();
     const KisTimeRange fullRange = animation->fullClipRange();
     const int frameRate = animation->framerate();
 
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("first_frame"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("last_frame"));
     KIS_SAFE_ASSERT_RECOVER_NOOP(configuration->hasProperty("include_audio"));
 
     const KisTimeRange clipRange(configuration->getInt("first_frame", fullRange.start()), configuration->getInt("last_frame", fullRange.end()));
     const bool includeAudio = configuration->getBool("include_audio", true);
 
     const QDir framesDir(configuration->getString("directory"));
 
     QString resultFile;
     if (QFileInfo(filename).isAbsolute()) {
         resultFile = filename;
     }
     else {
         resultFile = framesDir.absolutePath() + "/" + filename;
     }
     const QFileInfo info(resultFile);
     const QString suffix = info.suffix().toLower();
 
     const QString palettePath = framesDir.filePath("palette.png");
 
     const QString savedFilesMask = configuration->getString("savedFilesMask");
 
     const QStringList additionalOptionsList = configuration->getString("customUserOptions").split(' ', QString::SkipEmptyParts);
 
     if (suffix == "gif") {
         {
             QStringList args;
             args << "-r" << QString::number(frameRate)
-                 << "-pattern_type" << "glob"
+                 << "-start_number" << QString::number(clipRange.start())
                  << "-i" << savedFilesMask
                  << "-vf" << "palettegen"
                  << "-y" << palettePath;
 
             KisImageBuilder_Result result =
                 m_runner->runFFMpeg(args, i18n("Fetching palette..."),
                                     framesDir.filePath("log_generate_palette_gif.log"),
-                                    clipRange.duration() + clipRange.start());
+                                    clipRange.duration());
 
             if (result != KisImageBuilder_RESULT_OK) {
                 return result;
             }
         }
 
         {
             QStringList args;
             args << "-r" << QString::number(frameRate)
-                 << "-pattern_type" << "glob"
+                 << "-start_number" << QString::number(clipRange.start())
                  << "-i" << savedFilesMask
                  << "-i" << palettePath
                  << "-lavfi" << "[0:v][1:v] paletteuse"
                  << additionalOptionsList
                  << "-y" << resultFile;
 
-            dbgFile << "savedFilesMask" << savedFilesMask << "start" << clipRange.start() << "duration" << clipRange.duration();
+            dbgFile << "savedFilesMask" << savedFilesMask << "start" << QString::number(clipRange.start()) << "duration" << clipRange.duration();
 
             KisImageBuilder_Result result =
                 m_runner->runFFMpeg(args, i18n("Encoding frames..."),
                                     framesDir.filePath("log_encode_gif.log"),
-                                    clipRange.duration() + clipRange.start());
+                                    clipRange.duration());
 
             if (result != KisImageBuilder_RESULT_OK) {
                 return result;
             }
         }
     } else {
         QStringList args;
-        args << "-r" << QString::number(frameRate);
-        args << "-pattern_type" << "glob";
-        args << "-i" << savedFilesMask;
+        args << "-r" << QString::number(frameRate)
+             << "-start_number" << QString::number(clipRange.start())
+             << "-i" << savedFilesMask;
 
 
         QFileInfo audioFileInfo = animation->audioChannelFileName();
         if (includeAudio && audioFileInfo.exists()) {
             const int msecStart = clipRange.start() * 1000 / animation->framerate();
             const int msecDuration = clipRange.duration() * 1000 / animation->framerate();
 
             const QTime startTime = QTime::fromMSecsSinceStartOfDay(msecStart);
             const QTime durationTime = QTime::fromMSecsSinceStartOfDay(msecDuration);
             const QString ffmpegTimeFormat("H:m:s.zzz");
 
             args << "-ss" << startTime.toString(ffmpegTimeFormat);
             args << "-t" << durationTime.toString(ffmpegTimeFormat);
 
             args << "-i" << audioFileInfo.absoluteFilePath();
         }
 
         args << additionalOptionsList
              << "-y" << resultFile;
 
         result = m_runner->runFFMpeg(args, i18n("Encoding frames..."),
                                      framesDir.filePath("log_encode.log"),
-                                     clipRange.duration() + clipRange.start());
+                                     clipRange.duration());
     }
 
     return result;
 }
 
 void VideoSaver::cancel()
 {
     m_runner->cancel();
 }
 
 #include "video_saver.moc"