More optimizations and fixes

Author: Egor Vakhromtsev

README.md

@@ -7,8 +7,8 @@
 ### Benefits
 
 * Can read and composite RAW files with libraw. Useful for making previews of your shots before you start processing RAWs in your favourite processing software.
-* Reads many formats (with ImageMagick).
-* Can composite images with different methods (which ImageMagick support).
+* Reads many formats (with GraphicsMagick).
+* Can composite images with different methods (which GraphicsMagick support).
 * Ability to take fast previews of star trails or time lapse.
 * Cross platform. Should works on Linux, Mac and Windows.
 
@@ -66,11 +66,7 @@ So as you can clue, at one moment I finally saying that enough for me.
 And start make StarTrailer - the software which can gives you fast and nice preview of your great startrails.
 And you can just play with your night shots, even they stored in complicated RAW format.
 
-At the end of this story I want to send very big thanks to great authors of cool libs without which StarTrails can not were builded:
-
-* ImageMagick - http://www.imagemagick.org/
-* Libraw - http://www.libraw.su/
-* Qt - http://qt-project.org/
+At the end of this story I want to send very big thanks to great authors of cool libs without which StarTrails can not were builded.
 
 Thanks a lot!
 
@@ -83,7 +79,7 @@ Copyright (c) 2013-2024 Egor Vakhromtsev MIT Licensed, see [LICENSE-MIT] for det
 
 #### How to make star trails without this software
 
-1. Write your own script that use `convert -composite` from ImageMagick. Like [this][3] or [this one][5].
+1. Write your own script that use `convert -composite` from ImageMagick/GraphicsMagick. Like [this][3] or [this one][5].
 2. If you are on windows try [Startrails][6] application.
 
 

StarTrailer.pro

@@ -1,4 +1,6 @@
 TEMPLATE = subdirs
 CONFIG += debug_and_release
+CONFIG += c++17
 SUBDIRS = src tests
 QMAKE_CXXFLAGS += -Wall -Wno-error
+

src/compositetrailstask.cpp

@@ -15,7 +15,7 @@ CompositeTrailsTask::~CompositeTrailsTask()
 
 void CompositeTrailsTask::run()
 {
-    qDebug() << "CompositeTrailsTask::run() starts";
+    // qDebug() << "CompositeTrailsTask::run() starts";
     if (*m_stopped)
         return;
 
@@ -37,7 +37,7 @@ void CompositeTrailsTask::run()
 
         std::string s = m_sourceFiles[i].toStdString();
         try {
-         image.read(s, m_raw_processing_mode);
+         image.read(s, m_raw_processing_mode, m_jpeg_processing_mode);
         } catch (std::runtime_error &e) {
          qDebug() << "Can't read file: " << m_sourceFiles[i] << "\n" << e.what();
          continue;
@@ -87,8 +87,8 @@ void CompositeTrailsTask::run()
     if (counter > 0)
     {
         m_mutex->lock();
-        qDebug() << "preview WxH = " << m_preview_image->width() << "x" << m_preview_image->height();
-        qDebug() << "Tmp WxH = " << m_tmp_image->width() << "x" << m_tmp_image->height();
+        // qDebug() << "preview WxH = " << m_preview_image->width() << "x" << m_preview_image->height();
+        // qDebug() << "Tmp WxH = " << m_tmp_image->width() << "x" << m_tmp_image->height();
 
 //        if (m_out_image->height() == 0 && m_out_image->width() == 0) {
 //            //delete m_out_image;
@@ -108,12 +108,12 @@ void CompositeTrailsTask::run()
             delete resized_img;
         }
 
-        qDebug() << "Tmp WxH = " << m_tmp_image->width() << "x" << m_tmp_image->height();
+        // qDebug() << "Tmp WxH = " << m_tmp_image->width() << "x" << m_tmp_image->height();
 
         QMetaObject::invokeMethod(m_receiver, "redrawPreview", Qt::QueuedConnection, Q_ARG(bool, true));
         m_mutex->unlock();
     }
 
     QMetaObject::invokeMethod(m_receiver, "composingFinished", Qt::QueuedConnection);
-    qDebug() << "CompositeTrailsTask::run() ended";
+    // qDebug() << "CompositeTrailsTask::run() ended";
 }

src/compositetrailstask.h

@@ -21,7 +21,8 @@ class CompositeTrailsTask : public QRunnable
 //                                 StarTrailer::Image *out,
                                  StarTrailer::Image *preview,
                                  const Magick::CompositeOperator compose_op=Magick::LightenCompositeOp,
-                                 const StarTrailer::Image::RawProcessingMode raw_mode=StarTrailer::Image::FullPreview)
+                                 const StarTrailer::Image::RawProcessingMode raw_mode=StarTrailer::Image::FullPreview,
+                                 const StarTrailer::Image::JPEGProcessingMode jpeg_mode=StarTrailer::Image::FullJpeg)
 
         : m_receiver(receiver),
           m_stopped(stopped),
@@ -33,7 +34,8 @@ class CompositeTrailsTask : public QRunnable
           m_preview_image(preview),
 //          m_out_image(out),
           m_compose_op(compose_op),
-        m_raw_processing_mode(raw_mode)
+        m_raw_processing_mode(raw_mode),
+        m_jpeg_processing_mode(jpeg_mode)
     {
         //m_out_image(new Magick::Image(files.first().toStdString()))
         *m_stopped=false;
@@ -61,6 +63,7 @@ class CompositeTrailsTask : public QRunnable
     StarTrailer::Image * m_tmp_image = 0;
     const Magick::CompositeOperator m_compose_op;
     StarTrailer::Image::RawProcessingMode m_raw_processing_mode = StarTrailer::Image::FullPreview;
+    StarTrailer::Image::JPEGProcessingMode m_jpeg_processing_mode = StarTrailer::Image::FullJpeg;
 };
 
 #endif // COMPOSITETRAILSTASK_H

src/iconproxy.h

@@ -3,9 +3,9 @@
 
 #include <QIdentityProxyModel>
 #include <QFileSystemModel>
-#include <QtWidgets>
 #include <QtConcurrent/QtConcurrent>
 #include <QThreadPool>
+#include <QCache>
 #include <QDebug>
 
 /// A thread-safe function that returns an icon for an item with a given path.
@@ -14,12 +14,15 @@ QIcon getThumbnailIcon(const QString & path);
 
 class IconProxy : public QIdentityProxyModel {
     Q_OBJECT
-    QMap<QString, QIcon> m_icons;
+    // QMap<QString, QIcon> m_icons;
+    QCache<QString, const QIcon> m_icons;
     Q_SIGNAL void hasIcon(const QString&, const QIcon&, const QPersistentModelIndex& index) const;
 
     void onIcon(const QString& path, const QIcon& icon, const QPersistentModelIndex& index) {
-        m_icons.insert(path, icon);
-        emit dataChanged(index, index, QVector<int>{QFileSystemModel::FileIconRole});
+        if (!icon.isNull()) {
+            m_icons.insert(path, new QIcon(icon));
+            emit dataChanged(index, index, QVector<int>{QFileSystemModel::FileIconRole});
+        }
     }
     QThreadPool *runnersPool=0;
 
@@ -29,21 +32,34 @@ class IconProxy : public QIdentityProxyModel {
 
         if (role == QFileSystemModel::FileIconRole && index.column() == 0) {
             auto path = index.data(QFileSystemModel::FilePathRole).toString();
-            auto it = m_icons.find(path);
-            if (it != m_icons.end()) {
+            const QIcon *it = m_icons[path];
+            if (it != nullptr) {
+                return *it;
+            } else {
+                QPersistentModelIndex pIndex{index};
+                QtConcurrent::run(runnersPool, [this,path,pIndex]{
+                    emit hasIcon(path, getThumbnailIcon(path), pIndex);
+                });
+            }
+
+            /*f (it != m_icons.end()) {
                 if (! it->isNull()) return *it;
                 return QIdentityProxyModel::data(index, role);
-            }
-            QPersistentModelIndex pIndex{index};
-            QtConcurrent::run(runnersPool, [this,path,pIndex]{
-                emit hasIcon(path, getThumbnailIcon(path), pIndex);
-            });
-            return QVariant{};
+            }*/
+
+            // QPersistentModelIndex pIndex{index};
+            // QtConcurrent::run(runnersPool, [this,path,pIndex]{
+            //     emit hasIcon(path, getThumbnailIcon(path), pIndex);
+            // });
+            // return QIcon();
+            // return QVariant{};
+            return QIdentityProxyModel::data(index, role);
         }
         return QIdentityProxyModel::data(index, role);
     }
 
     IconProxy(QObject * parent = nullptr) : QIdentityProxyModel{parent} {
+        m_icons.setMaxCost(8192);
         connect(this, &IconProxy::hasIcon, this, &IconProxy::onIcon);
 
         runnersPool = new QThreadPool();

src/image.cpp

@@ -1,5 +1,14 @@
 #include "image.h"
 #include <cassert>
+#include <cstddef>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <filesystem> // C++17
+#include <algorithm>
+#include <string>
 
 const int DEFAULT_JPEG_QUALITY=95;
 
@@ -16,10 +25,10 @@ Image::Image(const Image &from_image)
     raw_processor = new LibRaw();
 }
 
-Image::Image(const std::string &file, Image::RawProcessingMode raw_processing_mode)
+Image::Image(const std::string &file, Image::RawProcessingMode raw_processing_mode, Image::JPEGProcessingMode jpeg_processing_mode)
 {
     init();
-    read(file, raw_processing_mode);
+    read(file, raw_processing_mode, jpeg_processing_mode);
 }
 
 Image::Image(const Magick::Image &from_image)
@@ -43,13 +52,24 @@ Image::~Image()
 //    }
 }
 
-void Image::read(const std::string &file, RawProcessingMode raw_processing_mode) {
+void Image::read(const std::string &file, RawProcessingMode raw_processing_mode, JPEGProcessingMode jpeg_processing_mode) {
     const std::lock_guard<std::mutex> lock(image_mutex);
+    std::string extension = file.substr(file.find_last_of(".") + 1);
+    std::transform(extension.begin(), extension.end(), extension.begin(), ::toupper);
+
+    if (jpeg_processing_mode == PreviewJPEG && (extension == "JPG" || extension == "JPEG" || extension == "JPE")) {
+        try {
+            read_preview_from_jpeg(file);
+            return;
+        } catch (const std::runtime_error &e) {
+            // do nothing
+        }
+    }
 
     assert(raw_processor != 0);    
     if (LIBRAW_SUCCESS == raw_processor->open_file(file.c_str())) {
         try {
-          switch (raw_processing_mode) {
+          switch (raw_processing_mode) {          
           case FullPreview:
             read_preview_with_libraw(file);
             break;
@@ -126,7 +146,7 @@ void Image::read_with_image_magick(const std::string &file)
     }
     catch(Magick::Error &error)
     {
-       throw std::runtime_error(std::string("Can't open file: ") + file + std::string("ImageMagick reports: ") + error.what());
+       throw std::runtime_error(std::string("Can't open file: ") + file + std::string("GraphicsMagick reports: ") + error.what());
     }
     catch( std::exception &error )
     {
@@ -151,6 +171,11 @@ void Image::read_preview_with_libraw(const std::string &file)
     {
         // memory copied here
         Magick::Blob blob(raw_processor->imgdata.thumbnail.thumb, raw_processor->imgdata.thumbnail.tlength);
+
+        // How no avoid double free (via blob destructor and libraw's resycle method?)
+        // Magick::Blob blob;//(buf, preview_length);
+        // blob.updateNoCopy(raw_processor->imgdata.thumbnail.thumb, raw_processor->imgdata.thumbnail.tlength, Magick::Blob::MallocAllocator);
+
         image->read(blob);
     }
         break;
@@ -176,6 +201,72 @@ void Image::read_preview_with_libraw(const std::string &file)
     raw_processor->recycle();
 }
 
+void Image::read_preview_from_jpeg(const std::string &file)
+{
+    assert(raw_processor != 0);
+    struct stat statbuf;
+
+    if (stat(file.c_str(), &statbuf) == -1)
+    {
+        throw std::runtime_error("failed to stat!");
+    }
+
+    FILE *f = fopen(file.c_str(), "rb");
+    if (f == NULL) {
+        throw std::runtime_error("failed open file!");
+    }
+
+    int c=-1;
+    int prev=-1;
+    bool in_image = 0;
+    size_t from=0;
+    size_t to=0;
+
+    const int max_preview_length = 1024*1024;
+    fseek(f, statbuf.st_size - max_preview_length, SEEK_SET);
+
+    while ((c = fgetc(f)) != EOF){
+        if (prev == 0xFF) {
+            if (in_image == 0 && c == 0xD8) {
+                in_image = 1;
+                from = ftell(f)-2;
+            } else {
+                if (in_image && c == 0xD9) {
+                    to = ftell(f);
+                    in_image = 0;
+                }
+            }
+        }
+
+        prev = c;
+    };
+
+    size_t preview_length = to - from;
+    if (preview_length == 0) {
+        fclose(f);
+        throw std::runtime_error("jpeg preview not found");
+    }
+
+    fseek(f, from, SEEK_SET);
+    void *buf = malloc(preview_length);
+    if (buf == nullptr) {
+        throw std::runtime_error("Can't allocate buffer!");
+
+    }
+    size_t result = fread(buf, 1, preview_length, f);
+    if (result != preview_length) {
+        free(buf);
+        throw std::runtime_error("File reading error!");
+    }
+    fclose(f);
+
+    Magick::Blob blob;//(buf, preview_length);
+    blob.updateNoCopy(buf, preview_length, Magick::Blob::MallocAllocator);
+    image->read(blob);
+
+    //free(buf); // should no free when updateNoCopy() from Magick::Blob used
+}
+
 void Image::read_raw_with_libraw(const std::string &file, const bool half_size)
 {
     assert(raw_processor != 0);

src/image.h

@@ -24,7 +24,7 @@
 ///  img5 = new Image('photo.cr2', Image::ProcessingMode::Preview);  // same as img2
 ///
 ///  // From memory
-///  img6 = new Image(buffer_ptr, buffer_size); // load blob from memory (blob is content of file), guess format with ImageMagick
+///  img6 = new Image(buffer_ptr, buffer_size); // load blob from memory (blob is content of file), guess format with GraphicsMagick
 ///  img7 = new Image(buffer_ptr, buffer_size, Image::Format::RGB24);
 ///
 ///  // From other objects
@@ -59,9 +59,10 @@ class Image
 {
 public:
     enum RawProcessingMode {UndefinedRawProcessingMode, HalfRaw, FullRaw, TinyPreview, SmallPreview, FullPreview};
+    enum JPEGProcessingMode {UndefinedJPEGProcessingMode, FullJpeg, PreviewJPEG};
 
     Image();
-    Image(const std::string &file, RawProcessingMode raw_processing_mode=FullPreview);
+    Image(const std::string &file, RawProcessingMode raw_processing_mode=FullPreview, JPEGProcessingMode jpeg_processing_mode=FullJpeg);
     Image(const Magick::Image &image);
     Image(const Image &from_image);
     Image & operator = (const Image & other)
@@ -78,7 +79,7 @@ class Image
 
     virtual ~Image();
 
-    void read(const std::string &file, RawProcessingMode raw_processing_mode=FullPreview);
+    void read(const std::string &file, RawProcessingMode raw_processing_mode=FullPreview, JPEGProcessingMode jpeg_processing_mode=FullJpeg);
     void write(const std::string &new_file);
 
     size_t to_buffer(void * &write_to_ptr);
@@ -155,6 +156,7 @@ class Image
 
     void read_with_image_magick(const std::string &file);
     void read_preview_with_libraw(const std::string &file);
+    void read_preview_from_jpeg(const std::string &file);
     void read_raw_with_libraw(const std::string &file, const bool half_size=false);
 
     void delete_data();

src/main.cpp

@@ -6,7 +6,7 @@ Q_DECLARE_METATYPE(Magick::Image*)
 
 int main(int argc, char *argv[])
 {
-    Magick::InitializeMagick(*argv);
+    Magick::InitializeMagick(*argv);    
     QApplication a(argc, argv);
     MainWindow w;
     w.show();