diff --git a/plugins/impex/csv/csv_loader.cpp b/plugins/impex/csv/csv_loader.cpp
index 416da74f4b..7ebf6d03fb 100644
--- a/plugins/impex/csv/csv_loader.cpp
+++ b/plugins/impex/csv/csv_loader.cpp
@@ -1,489 +1,488 @@
 /*
  *  Copyright (c) 2016 Laszlo Fazekas <mneko@freemail.hu>
  *
  *  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 "csv_loader.h"
 
 #include <QDebug>
 #include <QApplication>
 
 #include <QFile>
 #include <QVector>
 #include <QIODevice>
 #include <QStatusBar>
 #include <QFileInfo>
 
 #include <KisPart.h>
 #include <KisView.h>
 #include <KisDocument.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 
 #include <kis_debug.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_raster_keyframe_channel.h>
 #include <kis_image_animation_interface.h>
 #include <kis_time_range.h>
 
 #include "csv_read_line.h"
 #include "csv_layer_record.h"
 
 CSVLoader::CSVLoader(KisDocument *doc, bool batchMode)
     : m_image(0)
     , m_doc(doc)
     , m_batchMode(batchMode)
     , m_stop(false)
 {
 }
 
 CSVLoader::~CSVLoader()
 {
 }
 
 KisImportExportErrorCode CSVLoader::decode(QIODevice *io, const QString &filename)
 {
     QString     field;
     int         idx;
     int         frame = 0;
 
     QString     projName;
     int         width = 0;
     int         height = 0;
     int         frameCount = 1;
     float       framerate = 24.0;
     float       pixelRatio = 1.0;
 
     int         projNameIdx = -1;
     int         widthIdx = -1;
     int         heightIdx = -1;
     int         frameCountIdx = -1;
     int         framerateIdx = -1;
     int         pixelRatioIdx = -1;
 
     QVector<CSVLayerRecord*> layers;
 
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
     idx = filename.lastIndexOf(QRegExp("[\\/]"));
     QString base = (idx == -1) ? QString() : filename.left(idx + 1); //include separator
     QString path = filename;
 
     if (path.right(4).toUpper() == ".CSV")
         path = path.left(path.size() - 4);
 
     //according to the QT docs, the slash is a universal directory separator
     path.append(".frames/");
 
     KisImportExportErrorCode retval = ImportExportCodes::OK;
 
     dbgFile << "pos:" << io->pos();
 
     CSVReadLine readLine;
     QScopedPointer<KisDocument> importDoc(KisPart::instance()->createDocument());
     importDoc->setInfiniteAutoSaveInterval();
     importDoc->setFileBatchMode(true);
 
     KisView *setView(0);
 
     if (!m_batchMode) {
         // TODO: use other systems of progress reporting (KisViewManager::createUnthreadedUpdater()
 
 //        //show the statusbar message even if no view
 //        Q_FOREACH (KisView* view, KisPart::instance()->views()) {
 //            if (view && view->document() == m_doc) {
 //                setView = view;
 //                break;
 //            }
 //        }
 
 //        if (!setView) {
 //            QStatusBar *sb = KisPart::instance()->currentMainwindow()->statusBar();
 //            if (sb) {
 //                sb->showMessage(i18n("Loading CSV file..."));
 //            }
 //        } else {
 //            emit m_doc->statusBarMessage(i18n("Loading CSV file..."));
 //        }
 
 //        emit m_doc->sigProgress(0);
 //        connect(m_doc, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
     }
     int step = 0;
 
     do {
         qApp->processEvents();
 
         if (m_stop) {
             retval = ImportExportCodes::Cancelled;
             break;
         }
 
         if ((idx = readLine.nextLine(io)) <= 0) {
             if ((idx < 0) ||(step < 5))
-                retval = ImportExportCodes::Failure;
-
+                retval = ImportExportCodes::FileFormatIncorrect;
             break;
         }
         field = readLine.nextField(); //first field of the line
 
         if (field.isNull()) continue; //empty row
 
         switch (step) {
 
         case 0 :    //skip first row
             step = 1;
             break;
 
         case 1 :    //scene header names
             step = 2;
 
             for (idx = 0; !field.isNull(); idx++) {
                 if (field == "Project Name") {
                     projNameIdx = idx;
 
                 } else if (field == "Width") {
                     widthIdx = idx;
 
                 } else if (field == "Height") {
                     heightIdx = idx;
 
                 } else if (field == "Frame Count") {
                     frameCountIdx = idx;
 
                 } else if (field == "Frame Rate") {
                     framerateIdx = idx;
 
                 } else if (field == "Pixel Aspect Ratio") {
                     pixelRatioIdx = idx;
                 }
                 field= readLine.nextField();
             }
             break;
 
         case 2 :    //scene header values
             step= 3;
 
             for (idx= 0; !field.isNull(); idx++) {
                 if (idx == projNameIdx) {
                     projName = field;
 
                 } else if (idx == widthIdx) {
                     width = field.toInt();
 
                 } else if (idx == heightIdx) {
                     height = field.toInt();
 
                 } else if (idx == frameCountIdx) {
                     frameCount = field.toInt();
 
                     if (frameCount < 1) frameCount= 1;
 
                 } else if (idx == framerateIdx) {
                     framerate = field.toFloat();
 
                 } else if (idx == pixelRatioIdx) {
                     pixelRatio = field.toFloat();
 
                 }
                 field= readLine.nextField();
             }
 
             if ((width < 1) || (height < 1)) {
                retval = ImportExportCodes::Failure;
                break;
             }
 
             retval = createNewImage(width, height, pixelRatio, projName.isNull() ? filename : projName);
             break;
 
         case 3 :    //create level headers
             if (field[0] != '#') break;
 
             for (; !(field = readLine.nextField()).isNull(); ) {
                 CSVLayerRecord* layerRecord = new CSVLayerRecord();
                 layers.append(layerRecord);
             }
             readLine.rewind();
             field = readLine.nextField();
             step = 4;
             Q_FALLTHROUGH();
 
         case 4 :    //level header
 
             if (field == "#Layers") {
                 //layer name
                 for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                     layers.at(idx)->name = field;
 
                 break;
             }
             if (field == "#Density") {
                 //layer opacity
                 for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                     layers.at(idx)->density = field.toFloat();
 
                 break;
             }
             if (field == "#Blending") {
                 //layer blending mode
                 for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                     layers.at(idx)->blending = field;
 
                 break;
             }
             if (field == "#Visible") {
                 //layer visibility
                 for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                     layers.at(idx)->visible = field.toInt();
 
                 break;
             }
             if (field == "#Folder") {
                 //CSV 1.1 folder location
                 for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++)
                     layers.at(idx)->path = validPath(field, base);
 
                 break;
             }
             if ((field.size() < 2) || (field[0] != '#') || !field[1].isDigit()) break;
 
             step = 5;
 
             Q_FALLTHROUGH();
 
         case 5 :    //frames
 
             if ((field.size() < 2) || (field[0] != '#') || !field[1].isDigit()) break;
 
             for (idx = 0; !(field = readLine.nextField()).isNull() && (idx < layers.size()); idx++) {
                 CSVLayerRecord* layer = layers.at(idx);
 
                 if (layer->last != field) {
                     if (!m_batchMode) {
                         //emit m_doc->sigProgress((frame * layers.size() + idx) * 100 /
                         //                        (frameCount * layers.size()));
                     }
                     retval = setLayer(layer, importDoc.data(), path);
                     layer->last = field;
                     layer->frame = frame;
                 }
             }
             frame++;
             break;
         }
     } while (retval.isOk());
 
     //finish the layers
 
     if (retval.isOk()) {
         if (m_image) {
             KisImageAnimationInterface *animation = m_image->animationInterface();
 
             if (frame > frameCount)
                 frameCount = frame;
 
             animation->setFullClipRange(KisTimeRange::fromTime(0,frameCount - 1));
             animation->setFramerate((int)framerate);
         }
 
         for (idx = 0; idx < layers.size(); idx++) {
             CSVLayerRecord* layer = layers.at(idx);
             //empty layers without any pictures are dropped
 
             if ((layer->frame > 0) || !layer->last.isEmpty()) {
                 retval = setLayer(layer, importDoc.data(), path);
 
                 if (!retval.isOk())
                     break;
             }
         }
     }
 
     if (m_image) {
         //insert the existing layers by the right order
         for (idx = layers.size() - 1; idx >= 0; idx--) {
             CSVLayerRecord* layer = layers.at(idx);
 
             if (layer->layer) {
                 m_image->addNode(layer->layer, m_image->root());
             }
         }
         m_image->unlock();
     }
     qDeleteAll(layers);
     io->close();
 
     if (!m_batchMode) {
         // disconnect(m_doc, SIGNAL(sigProgressCanceled()), this, SLOT(cancel()));
         // emit m_doc->sigProgress(100);
 
         if (!setView) {
             QStatusBar *sb = KisPart::instance()->currentMainwindow()->statusBar();
             if (sb) {
                 sb->clearMessage();
             }
         } else {
             emit m_doc->clearStatusBarMessage();
         }
     }
     QApplication::restoreOverrideCursor();
     return retval;
 }
 
 QString CSVLoader::convertBlending(const QString &blending)
 {
     if (blending == "Color") return COMPOSITE_OVER;
     if (blending == "Behind") return COMPOSITE_BEHIND;
     if (blending == "Erase") return COMPOSITE_ERASE;
     // "Shade"
     if (blending == "Light") return COMPOSITE_LINEAR_LIGHT;
     if (blending == "Colorize") return COMPOSITE_COLORIZE;
     if (blending == "Hue") return COMPOSITE_HUE;
     if (blending == "Add") return COMPOSITE_ADD;
     if (blending == "Sub") return COMPOSITE_INVERSE_SUBTRACT;
     if (blending == "Multiply") return COMPOSITE_MULT;
     if (blending == "Screen") return COMPOSITE_SCREEN;
     // "Replace"
     // "Substitute"
     if (blending == "Difference") return COMPOSITE_DIFF;
     if (blending == "Divide") return COMPOSITE_DIVIDE;
     if (blending == "Overlay") return COMPOSITE_OVERLAY;
     if (blending == "Light2") return COMPOSITE_DODGE;
     if (blending == "Shade2") return COMPOSITE_BURN;
     if (blending == "HardLight") return COMPOSITE_HARD_LIGHT;
     if (blending == "SoftLight") return COMPOSITE_SOFT_LIGHT_PHOTOSHOP;
     if (blending == "GrainExtract") return COMPOSITE_GRAIN_EXTRACT;
     if (blending == "GrainMerge") return COMPOSITE_GRAIN_MERGE;
     if (blending == "Sub2") return COMPOSITE_SUBTRACT;
     if (blending == "Darken") return COMPOSITE_DARKEN;
     if (blending == "Lighten") return COMPOSITE_LIGHTEN;
     if (blending == "Saturation") return COMPOSITE_SATURATION;
 
     return COMPOSITE_OVER;
 }
 
 QString CSVLoader::validPath(const QString &path,const QString &base)
 {
     //replace Windows directory separators with the universal /
 
     QString tryPath= QString(path).replace(QString("\\"), QString("/"));
     int i = tryPath.lastIndexOf("/");
 
     if (i == (tryPath.size() - 1))
         tryPath= tryPath.left(i); //remove the ending separator if exists
 
     if (QFileInfo(tryPath).isDir())
         return tryPath.append("/");
 
     QString scan(tryPath);
     i = -1;
 
     while ((i= (scan.lastIndexOf("/",i) - 1)) > 0) {
         //avoid testing if the next level will be the default xxxx.layers folder
 
         if ((i >= 6) && (scan.mid(i - 6, 7) == ".layers")) continue;
 
         tryPath= QString(base).append(scan.mid(i + 2)); //base already ending with a /
 
         if (QFileInfo(tryPath).isDir())
             return tryPath.append("/");
     }
     return QString(); //NULL string
 }
 
 KisImportExportErrorCode CSVLoader::setLayer(CSVLayerRecord* layer, KisDocument *importDoc, const QString &path)
 {
     bool result = true;
 
     if (layer->channel == 0) {
         //create a new document layer
 
         float opacity = layer->density;
 
         if (opacity > 1.0)
             opacity = 1.0;
         else if (opacity < 0.0)
             opacity = 0.0;
 
         const KoColorSpace* cs = m_image->colorSpace();
         const QString layerName = (layer->name).isEmpty() ? m_image->nextLayerName() : layer->name;
 
         KisPaintLayer* paintLayer = new KisPaintLayer(m_image, layerName,
                                                        (quint8)(opacity * OPACITY_OPAQUE_U8), cs);
 
         paintLayer->setCompositeOpId(convertBlending(layer->blending));
         paintLayer->setVisible(layer->visible);
         paintLayer->enableAnimation();
 
         layer->layer = paintLayer;
         layer->channel = qobject_cast<KisRasterKeyframeChannel*>
             (paintLayer->getKeyframeChannel(KisKeyframeChannel::Content.id(), true));
     }
 
 
     if (!layer->last.isEmpty()) {
         //png image
         QString filename = layer->path.isNull() ? path : layer->path;
         filename.append(layer->last);
 
         result = importDoc->openUrl(QUrl::fromLocalFile(filename),
                                     KisDocument::DontAddToRecent);
         if (result)
             layer->channel->importFrame(layer->frame, importDoc->image()->projection(), 0);
 
     } else {
         //blank
         layer->channel->addKeyframe(layer->frame);
     }
     return (result) ? ImportExportCodes::OK : ImportExportCodes::Failure;
 }
 
 KisImportExportErrorCode CSVLoader::createNewImage(int width, int height, float ratio, const QString &name)
 {
     //the CSV is RGBA 8bits, sRGB
 
     if (!m_image) {
         const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(
                                 RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), 0);
 
         if (cs) m_image = new KisImage(m_doc->createUndoStore(), width, height, cs, name);
 
         if (!m_image) return ImportExportCodes::Failure;
 
         m_image->setResolution(ratio, 1.0);
         m_image->lock();
     }
     return ImportExportCodes::OK;
 }
 
 KisImportExportErrorCode CSVLoader::buildAnimation(QIODevice *io, const QString &filename)
 {
     return decode(io, filename);
 }
 
 KisImageSP CSVLoader::image()
 {
     return m_image;
 }
 
 void CSVLoader::cancel()
 {
     m_stop = true;
 }
diff --git a/plugins/impex/heightmap/kis_heightmap_import.cpp b/plugins/impex/heightmap/kis_heightmap_import.cpp
index b5bae6c8ef..6e53044f7f 100644
--- a/plugins/impex/heightmap/kis_heightmap_import.cpp
+++ b/plugins/impex/heightmap/kis_heightmap_import.cpp
@@ -1,200 +1,204 @@
 /*
  *  Copyright (c) 2014 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2017 Victor Wåhlström <victor.wahlstrom@initiali.se>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; either version 2.1 of the License, or
  *  (at your option) any later version.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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_heightmap_import.h"
 
 #include <ctype.h>
 
 #include <QApplication>
 #include <qendian.h>
 
 #include <kpluginfactory.h>
 #include <KoDialog.h>
 
 #include <KisImportExportManager.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceTraits.h>
 
 #include <kis_debug.h>
 #include <KisDocument.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_transaction.h>
 #include <kis_iterator_ng.h>
 #include <kis_random_accessor_ng.h>
 #include <kis_config.h>
 
 #include "kis_wdg_options_heightmap.h"
 #include "kis_heightmap_utils.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(HeightMapImportFactory, "krita_heightmap_import.json", registerPlugin<KisHeightMapImport>();)
 
 template<typename T>
 void fillData(KisPaintDeviceSP pd, int w, int h, QDataStream &stream) {
     KIS_ASSERT_RECOVER_RETURN(pd);
 
     T pixel;
 
     for (int i = 0; i < h; ++i) {
         KisHLineIteratorSP it = pd->createHLineIteratorNG(0, i, w);
         do {
             stream >> pixel;
             KoGrayTraits<T>::setGray(it->rawData(), pixel);
             KoGrayTraits<T>::setOpacity(it->rawData(), OPACITY_OPAQUE_F, 1);
         } while(it->nextPixel());
     }
 }
 
 KisHeightMapImport::KisHeightMapImport(QObject *parent, const QVariantList &) : KisImportExportFilter(parent)
 {
 }
 
 KisHeightMapImport::~KisHeightMapImport()
 {
 }
 
 KisImportExportErrorCode KisHeightMapImport::convert(KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration)
 {
     Q_UNUSED(configuration);
     KoID depthId = KisHeightmapUtils::mimeTypeToKoID(mimeType());
     if (depthId.id().isNull()) {
         document->setErrorMessage(i18n("Unknown file type"));
         return ImportExportCodes::FileFormatIncorrect;
     }
 
     int w = 0;
     int h = 0;
 
     KIS_ASSERT(io->isOpen());
     const quint64 size = io->size();
+    if (size == 0) {
+        return ImportExportCodes::FileFormatIncorrect;
+    }
+
     QDataStream::ByteOrder bo = QDataStream::LittleEndian;
 
     if (!batchMode()) {
         QApplication::restoreOverrideCursor();
 
         KoDialog* kdb = new KoDialog(0);
         kdb->setWindowTitle(i18n("Heightmap Import Options"));
         kdb->setButtons(KoDialog::Ok | KoDialog::Cancel);
 
         KisWdgOptionsHeightmap* wdg = new KisWdgOptionsHeightmap(kdb);
 
         kdb->setMainWidget(wdg);
 
         connect(wdg, SIGNAL(statusUpdated(bool)), kdb, SLOT(enableButtonOk(bool)));
 
         KisConfig config(true);
 
         QString filterConfig = config.importConfiguration(mimeType());
         KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration);
         cfg->fromXML(filterConfig);
 
 
         int endianness = cfg->getInt("endianness", 1);
         if (endianness == 0) {
             wdg->radioBig->setChecked(true);
         }
         else {
             wdg->radioLittle->setChecked(true);
         }
 
         wdg->fileSizeLabel->setText(QString::number(size));
 
         if(depthId == Integer8BitsColorDepthID) {
             wdg->bppLabel->setText(QString::number(8));
             wdg->typeLabel->setText("Integer");
         }
         else if(depthId == Integer16BitsColorDepthID) {
             wdg->bppLabel->setText(QString::number(16));
             wdg->typeLabel->setText("Integer");
         }
         else if(depthId == Float32BitsColorDepthID) {
             wdg->bppLabel->setText(QString::number(32));
             wdg->typeLabel->setText("Float");
         }
         else {
             KIS_ASSERT_RECOVER_RETURN_VALUE(true, ImportExportCodes::InternalError);
             return ImportExportCodes::InternalError;
         }
 
         if (kdb->exec() == QDialog::Rejected) {
             return ImportExportCodes::Cancelled;
         }
 
         cfg->setProperty("endianness", wdg->radioBig->isChecked() ? 0 : 1);
 
         config.setImportConfiguration(mimeType(), cfg);
 
         w = wdg->widthInput->value();
         h = wdg->heightInput->value();
 
         bo = QDataStream::LittleEndian;
         cfg->setProperty("endianness", 1);
         if (wdg->radioBig->isChecked()) {
             bo = QDataStream::BigEndian;
             cfg->setProperty("endianness", 0);
         }
         KisConfig(true).setExportConfiguration(mimeType(), cfg);
 
     } else {
         const int pixelSize =
             depthId == Float32BitsColorDepthID ? 4 :
             depthId == Integer16BitsColorDepthID ? 2 : 1;
 
         const int numPixels = size / pixelSize;
 
         w = std::sqrt(numPixels);
         h = numPixels / w;
         bo = QDataStream::LittleEndian;
     }
 
 
     QDataStream s(io);
     s.setByteOrder(bo);
     // needed for 32bit float data
     s.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
     const KoColorSpace *colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), depthId.id(), "Gray-D50-elle-V2-srgbtrc.icc");
     KisImageSP image = new KisImage(document->createUndoStore(), w, h, colorSpace, "imported heightmap");
     KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), 255);
 
     if (depthId == Float32BitsColorDepthID) {
         fillData<float>(layer->paintDevice(), w, h, s);
     }
     else if (depthId == Integer16BitsColorDepthID) {
         fillData<quint16>(layer->paintDevice(), w, h, s);
     }
     else if (depthId == Integer8BitsColorDepthID) {
         fillData<quint8>(layer->paintDevice(), w, h, s);
     }
     else {
         KIS_ASSERT_RECOVER_RETURN_VALUE(true, ImportExportCodes::InternalError);
         return ImportExportCodes::InternalError;
     }
 
     image->addNode(layer.data(), image->rootLayer().data());
     document->setCurrentImage(image);
     return ImportExportCodes::OK;
 }
 
 #include "kis_heightmap_import.moc"