Ticket #7376: mythgallery-sort-by-exif-header-with-progressdialog.patch

mythgallery/mythgallery/galleryutil.h

@@ -21 +21 @@
 #define EXIFUTIL_H
 
 #include <QFileInfo>
-
 #include "iconview.h"
 
+#ifdef EXIF_SUPPORT
+#include <libexif/exif-data.h>
+#include <libexif/exif-entry.h>
+// include "exif.hpp"
+#endif // EXIF_SUPPORT
+
 class GalleryUtil
 {
  public:
@@ -34 +39 @@
     static bool IsImage(const QString &filePath);
     static bool IsMovie(const QString &filePath);
     static long GetNaturalRotation(const QString &filePath);
-
+    static long GetNaturalRotationDB(const QString &filePath, bool *ok);
+    static long GetDateTime(const QString &filePath);
+    static long GetDateTimeDB(const QString &filePath, bool *ok);
     static QString GetCaption(const QString &filePath);
 
+    static void SetDateTimeDB(const QString &filePath, long dateTime);
+    static void SetNaturalRotationDB(QString &filePath, long angle);
+
+#ifdef EXIF_SUPPORT
+    static QString GetExifHeaderTag(const QString &filePathString, ExifTag exifHeaderTag);
+#endif
+
     static bool LoadDirectory(ThumbList &itemList, const QString &dir,
                               int sortorder, bool recurse,
                               ThumbHash *itemHash, ThumbGenerator *thumbGen);
@@ -60 +74 @@
                                 const QString &newName);
 };
 
+#ifdef EXIF_SUPPORT
+class DirLoadingThread: public QThread
+{
+public:
+    DirLoadingThread();
+    virtual void run();
+
+    int GetProgress(void) { return m_progress; }
+    void SetData( QList<QFileInfo> *list, int sortorder );
+
+private:
+    int                 m_progress;
+    int                 m_sortorder;
+    QList<QFileInfo>   *m_list;
+};
+#endif
+
 #endif /* EXIFUTIL_H */

mythgallery/mythgallery/thumbview.cpp

@@ -7 +7 @@
 
 // MythTV plugin headers
 #include <mythdb.h>
+#include "mythcontext.h"
 
 // MythGallery headers
 #include "thumbview.h"
@@ -61 +62 @@
 
 void ThumbItem::SetRotationAngle(int angle)
 {
-    MSqlQuery query(MSqlQuery::InitCon());
-    query.prepare(
-        "REPLACE INTO gallerymetadata "
-        "SET image = :IMAGE, "
-        "    angle = :ANGLE");
-    query.bindValue(":IMAGE", m_path);
-    query.bindValue(":ANGLE", angle);
-
-    if (!query.exec())
-        MythDB::DBError("set_rotation_angle", query);
-
+    VERBOSE(VB_IMPORTANT, QString("ThumbItem::SetRotationAngle(angle): angle into database: '%1'").arg(angle));
+    GalleryUtil::SetNaturalRotationDB(m_path, angle);
     SetPixmap(NULL);
 }
 
@@ -82 +74 @@
     m_pixmap = pixmap;
 }
 
+
 long ThumbItem::GetRotationAngle(void)
-{
-    MSqlQuery query(MSqlQuery::InitCon());
+{  
+    // Load the rotation in from the database. It should
+    // have been set during the thumbnail creation phase
+    bool ok = false;
+    long angle = GalleryUtil::GetNaturalRotationDB(m_path, &ok);
 
-    // first try to find the exact file
-    query.prepare(
-        "SELECT angle "
-        "FROM gallerymetadata "
-        "WHERE image = :PATH");
-    query.bindValue(":PATH", m_path);
+    return angle;
 
-    if (!query.exec() || !query.isActive())
-        MythDB::DBError("get_rotation_angle", query);
-    else if (query.next())
-        return query.value(0).toInt();
+/*
+    // Load the rotation in from the database to speed up
+    // the rotation later. If the data is not available then
+    // get the rotation information from the exif header.
+    bool ok = false;
+    long rotateAngle = GalleryUtil::GetNaturalRotationDB(m_path, &ok);
 
-    // second try to find the first image in the same directory
-    query.prepare(
-        "SELECT angle, image "
-        "FROM gallerymetadata "
-        "WHERE image LIKE :PATH "
-        "ORDER BY image");
-    query.bindValue(":PATH", m_path + '%');
+    if (rotateAngle == -1 || !ok)
+    {
+        // we dont have a value. try to get it from the exif header
+        rotateAngle = GalleryUtil::GetNaturalRotation(m_path);
 
-    if (!query.exec() || !query.isActive())
-        MythDB::DBError("get_rotation_angle", query);
-    else if (query.next())
-        return query.value(0).toInt();
-
-    return GalleryUtil::GetNaturalRotation(m_path);
+        // if we have a value then update the database
+        if ( rotateAngle != -1 )
+            GalleryUtil::SetNaturalRotationDB(m_path, rotateAngle);
+    }
+    return rotateAngle;
+*/
 }
 
+
 QString ThumbItem::GetDescription(const QString &status,
                                   const QSize &sz, int angle) const
 {

mythgallery/mythgallery/gallerysettings.cpp

@@ -42 +42 @@
     gc->addSelection("Reverse Name (Z-A alpha)", QString::number(QDir::Name | QDir::DirsFirst | QDir::IgnoreCase | QDir::Reversed));
     gc->addSelection("Mod Time (earliest first)", QString::number(QDir::Time | QDir::DirsFirst | QDir::IgnoreCase | QDir::Reversed));
     gc->addSelection("Reverse Mod Time (most recent first)", QString::number(QDir::Time | QDir::DirsFirst | QDir::IgnoreCase));
+#ifdef EXIF_SUPPORT
+    gc->addSelection("Creation Time (earliest first)", QString::number( 0x1000 | QDir::Reversed) );
+    gc->addSelection("Reverse Creation Time (most recent first)", QString::number( 0x1000 ) );
+#endif
     gc->setHelpText(QObject::tr("This is the sort order for the displayed "
                     "picture thumbnails."));
     return gc;
 };
 
+static HostCheckBox *MythGalleryScaleMax()
+{
+    HostCheckBox *gc = new HostCheckBox("GalleryScaleMax");
+    gc->setLabel(QObject::tr("Scale image to the maximum screen size"));
+    gc->setHelpText(QObject::tr("Check this to scale the image to the maximum "
+                                "No black borders will be visible."));
+    return gc;
+};
+
 static HostLineEdit *MythGalleryMoviePlayerCmd()
 {
     HostLineEdit *gc = new HostLineEdit("GalleryMoviePlayerCmd");
@@ -205 +218 @@
         addChild(SlideshowDelay());
         addChild(SlideshowRecursive());
     }
-
 };
 
 
@@ -215 +227 @@
     general->setLabel(QObject::tr("MythGallery Settings (General)"));
     general->addChild(MythGalleryDir());
     general->addChild(MythGalleryThumbnailLocation());
+    general->addChild(MythGalleryScaleMax());
     general->addChild(MythGallerySortOrder());
     general->addChild(MythGalleryImportDirs());
     general->addChild(MythGalleryMoviePlayerCmd());

mythgallery/mythgallery/dbcheck.cpp

@@ -12 +12 @@
 // mythgallery
 #include "dbcheck.h"
 
-const QString currentDatabaseVersion = "1003";
+const QString currentDatabaseVersion = "1004";
 
 static bool UpdateDBVersionNumber(const QString &newnumber)
 {
-
     if (!gCoreContext->SaveSettingOnHost("GalleryDBSchemaVer",newnumber,NULL))
     {
         VERBOSE(VB_IMPORTANT,
@@ -45 +44 @@
         if (!query.exec(thequery))
         {
             QString msg =
-                QString("DB Error (Performing database upgrade): \n"
-                        "Query was: %1 \nError was: %2 \nnew version: %3")
-                .arg(thequery)
-                .arg(MythDB::DBErrorMessage(query.lastError()))
-                .arg(version);
+                    QString("DB Error (Performing database upgrade): \n"
+                            "Query was: %1 \nError was: %2 \nnew version: %3")
+                    .arg(thequery)
+                    .arg(MythDB::DBErrorMessage(query.lastError()))
+                    .arg(version);
             VERBOSE(VB_IMPORTANT, msg);
             return false;
         }
@@ -78 +77 @@
                 "Inserting MythGallery initial database information.");
 
         const QString updates[] = {
-"CREATE TABLE IF NOT EXISTS gallerymetadata ("
-"  image VARCHAR(255) NOT NULL PRIMARY KEY,"
-"  angle INTEGER NOT NULL"
-");",
-"INSERT INTO settings VALUES ('GalleryDBSchemaVer', 1000, NULL);",
-""
-};
+            "CREATE TABLE IF NOT EXISTS gallerymetadata ("
+                    "  image VARCHAR(255) NOT NULL PRIMARY KEY,"
+                    "  angle INTEGER NOT NULL"
+                    ");",
+                    "INSERT INTO settings VALUES ('GalleryDBSchemaVer', 1000, NULL);",
+                    ""
+                };
         if (!performActualUpdate(updates, "1000", dbver))
             return false;
     }
 
-
-
     if (dbver == "1000")
     {
         const QString updates[] = {
-QString("ALTER DATABASE %1 DEFAULT CHARACTER SET latin1;")
-        .arg(gContext->GetDatabaseParams().dbName),
-"ALTER TABLE gallerymetadata"
-"  MODIFY image varbinary(255) NOT NULL;",
-""
-};
+            QString("ALTER DATABASE %1 DEFAULT CHARACTER SET latin1;")
+                    .arg(gCoreContext->GetDatabaseParams().dbName),
+                    "ALTER TABLE gallerymetadata"
+                    "  MODIFY image varbinary(255) NOT NULL;",
+                    ""
+                };
 
         if (!performActualUpdate(updates, "1001", dbver))
             return false;
     }
 
-
     if (dbver == "1001")
     {
         const QString updates[] = {
-QString("ALTER DATABASE %1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;")
-        .arg(gContext->GetDatabaseParams().dbName),
-"ALTER TABLE gallerymetadata"
-"  DEFAULT CHARACTER SET default,"
-"  MODIFY image varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;",
-""
-};
+            QString("ALTER DATABASE %1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;")
+                    .arg(gContext->GetDatabaseParams().dbName),
+                    "ALTER TABLE gallerymetadata"
+                    "  DEFAULT CHARACTER SET default,"
+                    "  MODIFY image varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL;",
+                    ""
+                };
 
         if (!performActualUpdate(updates, "1002", dbver))
             return false;
@@ -124 +120 @@
     if (dbver == "1002")
     {
         const QString updates[] = {
-"DELETE FROM keybindings "
-" WHERE action = 'DELETE' AND context = 'Gallery';",
-""
-};
+            "DELETE FROM keybindings "
+                    " WHERE action = 'DELETE' AND context = 'Gallery';",
+                    ""
+                };
 
         if (!performActualUpdate(updates, "1003", dbver))
             return false;
     }
 
+    if (dbver == "1003")
+    {
+        const QString updates[] = {
+            "ALTER TABLE `gallerymetadata` ADD `datetime` INT NOT NULL DEFAULT '0' AFTER `angle`;",
+            "ALTER TABLE `gallerymetadata` CHANGE `angle` `angle` INT( 11 ) NOT NULL DEFAULT '0';",
+            ""
+        };
+        if (!performActualUpdate(updates, "1004", dbver))
+            return false;
+    }
+
     return true;
 }

mythgallery/mythgallery/iconview.cpp

@@ -313 +313 @@
                             .arg(ThumbGenerator::getThumbcacheDir(m_currDir))
                             .arg(item->GetName());
 
-//         int rotateAngle = 0;
-//
-//         rotateAngle = item->GetRotationAngle();
-//
-//         if (rotateAngle != 0)
-//         {
-//             QMatrix matrix;
-//             matrix.rotate(rotateAngle);
-//             image = image.xForm(matrix);
-//         }
     item->SetImageFilename(imagePath);
 }
 

mythgallery/mythgallery/thumbgenerator.cpp

@@ -323 +323 @@
     }
     else
     {
+        QString filePath = fi.canonicalFilePath();
 #ifdef EXIF_SUPPORT
+
         // Try to get thumbnail from exif data
-        ExifData *ed = exif_data_new_from_file(fi.absoluteFilePath()
-                                               .toLocal8Bit().constData());
+        ExifData *ed = exif_data_new_from_file(
+                filePath.toLocal8Bit().constData());
+
         if (ed && ed->data)
-        {
             image.loadFromData(ed->data, ed->size);
-        }
 
         if (ed)
             exif_data_free(ed);
@@ -338 +339 @@
         if (image.width() > m_width && image.height() > m_height)
             return;
 #endif
+        // There was no thumbnail image in the exif header.
+        // Load the image regularily.
+        image.load(filePath);
 
-        image.load(fi.absoluteFilePath());
+        long angle = 0;
+        
+#ifdef EXIF_SUPPORT
+        
+        // This is the first time we create the thumbnail.
+        // Load the rotation angle from the exif header
+        angle = GalleryUtil::GetNaturalRotation(filePath);
+
+        // if we have an angle other than the default
+        // of 0 degrees save it in the database.
+        if ( angle != 0 )
+            GalleryUtil::SetNaturalRotationDB(filePath, angle);
+#endif
+
+        // rotate the thumbnail image
+        if (angle != 0 )
+        {
+            QMatrix matrix;
+            matrix.rotate(angle);
+            image = image.transformed(matrix);
+        }
     }
 }
 

mythgallery/mythgallery/galleryutil.cpp

@@ -18 +18 @@
 
 // qt
 #include <QDir>
+#include <QApplication>
 
 // myth
 #include <mythcontext.h>
@@ -26 +27 @@
 #include <mythdirs.h>
 #include <mythdb.h>
 #include <mythuihelper.h>
+#include <mythprogressdialog.h>
 
 // mythgallery
 #include "config.h"
 #include "galleryutil.h"
 #include "thumbgenerator.h"
 
-#ifdef EXIF_SUPPORT
-#include <libexif/exif-data.h>
-#include <libexif/exif-entry.h>
-// include "exif.hpp"
-#endif // EXIF_SUPPORT
-
 #define LOC QString("GalleryUtil:")
 #define LOC_ERR QString("GalleryUtil, Error:")
 
@@ -124 +120 @@
     return false;
 }
 
-long GalleryUtil::GetNaturalRotation(const QString &filePathString)
+long GalleryUtil::GetNaturalRotation(const QString &filePath)
 {
     long rotateAngle = 0;
-    QByteArray filePathBA = filePathString.toLocal8Bit();
-    const char *filePath = filePathBA.constData();
 
+#ifdef EXIF_SUPPORT
+    // get the value from the header. Check also with different languages
+    // because the value depends on the language used by the camera
+    QString value = GetExifHeaderTag( filePath, EXIF_TAG_ORIENTATION);
+
+    if (value == "left - bottom" ||
+        value == "links - unten")
+    {
+        rotateAngle = -90;
+    }
+    else if (value == "right - top" ||
+             value == "rechts - oben")
+    {
+        rotateAngle = 90;
+    }
+#endif
+
+    return rotateAngle;
+}
+
+long GalleryUtil::GetNaturalRotationDB(const QString &filePath, bool *ok)
+{
+    // default value if no value is found
+    long angle = 0;
+
+    *ok = false;
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    // first try to find the exact file
+    query.prepare(
+        "SELECT angle "
+        "FROM gallerymetadata "
+        "WHERE image = :PATH");
+    query.bindValue(":PATH", filePath);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("get_rotation_angle", query);
+    }
+    else if (query.next())
+    {
+        *ok = true;
+        return query.value(0).toString().toLong();
+    }
+
+    // second try to find the first image in the same directory
+    query.prepare(
+        "SELECT angle, image "
+        "FROM gallerymetadata "
+        "WHERE image LIKE :PATH "
+        "ORDER BY image");
+    query.bindValue(":PATH", filePath + '%');
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("get_rotation_angle", query);
+    }
+    else if (query.next())
+    {
+        *ok = true;
+        return query.value(0).toString().toLong();
+    }
+
+    return angle;
+}
+
+QString GalleryUtil::GetCaption(const QString &filePath)
+{
+    QString caption("");
+
+#ifdef EXIF_SUPPORT
+    // try to get the user comment
+    caption = GetExifHeaderTag( filePath, EXIF_TAG_USER_COMMENT);
+
+    if(!caption.isEmpty())
+        return caption;
+
+    // try to get the tag image description
+    caption = GetExifHeaderTag( filePath, EXIF_TAG_IMAGE_DESCRIPTION);
+
+    if(!caption.isEmpty())
+        return caption;
+#endif
+
+    return caption;
+}
+
+long GalleryUtil::GetDateTime(const QString &filePath)
+{
+    // default value if no value is found
+    long utcTime = 0;
+
+#ifdef EXIF_SUPPORT
+    QString value = GetExifHeaderTag( filePath, EXIF_TAG_DATE_TIME);
+
+    // convert the string into the UTC time. We need to split
+    // the exif time format, which is this: "2006:07:21 18:54:58"
+    bool ok;
+    QDateTime dateTime = QDateTime( QDate( value.mid(0,4).toInt(&ok, 10),
+                                           value.mid(5,2).toInt(&ok, 10),
+                                           value.mid(8,2).toInt(&ok, 10)),
+                                    QTime( value.mid(11,2).toInt(&ok, 10),
+                                           value.mid(14,2).toInt(&ok, 10),
+                                           value.mid(17,2).toInt(&ok, 10), 0));
+
+    // convert it to the utc time so we can easily compare it later.
+    utcTime = dateTime.toTime_t();
+#endif
+
+    return utcTime;
+}
+
+long GalleryUtil::GetDateTimeDB(const QString &filePath, bool *ok)
+{
+    // default value if no value is found
+    long dateTime = 0;
+
+    *ok = false;
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    // first try to find the exact file
+    query.prepare(
+        "SELECT datetime "
+        "FROM gallerymetadata "
+        "WHERE image = :PATH");
+    query.bindValue(":PATH", filePath);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("get_datetime", query);
+    }
+    else if (query.next())
+    {
+        *ok = true;
+        return query.value(0).toString().toLong();
+    }
+
+    // second try to find the first image in the same directory
+    query.prepare(
+        "SELECT datetime, image "
+        "FROM gallerymetadata "
+        "WHERE image LIKE :PATH "
+        "ORDER BY image");
+    query.bindValue(":PATH", filePath + '%');
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("get_datetime", query);
+     }
+    else if (query.next())
+    {
+        *ok = true;
+        return query.value(0).toString().toLong();
+    }
+
+    // if everything fails return the default
+    return dateTime;
+}
+
+void GalleryUtil::SetDateTimeDB(const QString &filePath, long dateTime)
+{
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "UPDATE gallerymetadata "
+        "SET datetime = :DATETIME "
+        "WHERE image = :IMAGE LIMIT 1");
+    query.bindValue(":IMAGE", filePath);
+    query.bindValue(":DATETIME", QString::number(dateTime,10));
+
+    if (!query.exec())
+        MythDB::DBError("set_datetime", query);
+
+    // Check if the update failed because of a missing database
+    // entry. In this case we need to insert a new dataset.
+    if (query.numRowsAffected() == 0)
+    {
+        query.prepare(
+            "REPLACE INTO gallerymetadata "
+            "SET image    = :IMAGE, "
+            "    datetime = :DATETIME");
+        query.bindValue(":IMAGE", filePath);
+        query.bindValue(":DATETIME", QString::number(dateTime, 10));
+
+        if (!query.exec())
+            MythDB::DBError("set_datetime", query);
+    }
+}
+
+void GalleryUtil::SetNaturalRotationDB(QString &filePath, long angle)
+{
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "UPDATE gallerymetadata "
+        "SET angle = :ANGLE "
+        "WHERE image = :IMAGE LIMIT 1");
+    query.bindValue(":IMAGE", filePath);
+    query.bindValue(":ANGLE", QString::number(angle, 10));
+
+    if (!query.exec())
+        MythDB::DBError("set_rotation_angle", query);
+
+    // Check if the update failed because of a missing database
+    // entry. In this case we need to insert a new dataset.
+    if (query.numRowsAffected() == 0)
+    {
+        query.prepare(
+            "REPLACE INTO gallerymetadata "
+            "SET image = :IMAGE, "
+            "    angle = :ANGLE");
+        query.bindValue(":IMAGE", filePath);
+        query.bindValue(":ANGLE", QString::number(angle, 10));
+
+        if (!query.exec())
+            MythDB::DBError("set_datetime", query);
+    }
+}
+
+#ifdef EXIF_SUPPORT
+QString GalleryUtil::GetExifHeaderTag(const QString &filePath, ExifTag exifHeaderTag)
+{
+    QString value("");
+
+    // dont get the exif information from non defined pictures
+    if (!IsImage(filePath))
+        return value;
+
     try
     {
-#ifdef EXIF_SUPPORT
+        // get the exif header from the specified file
         char *exifvalue = new char[1024];
-        ExifData *data = exif_data_new_from_file (filePath);
+        ExifData *data = exif_data_new_from_file (filePath.toLocal8Bit().constData());
         if (data)
         {
+            // we have some data, go through all available header
+            // tags and stop when we have reached the desired tag
             for (int i = 0; i < EXIF_IFD_COUNT; i++)
             {
-                ExifEntry *entry = exif_content_get_entry (data->ifd[i],
-                                                        EXIF_TAG_ORIENTATION);
-                ExifByteOrder byteorder = exif_data_get_byte_order (data);
+                ExifEntry *entry = exif_content_get_entry (data->ifd[i], exifHeaderTag);
 
                 if (entry)
                 {
-                    ExifShort v_short = exif_get_short (entry->data, byteorder);
-                    VERBOSE(VB_GENERAL|VB_EXTRA, QString("Exif entry=%1").arg(v_short));
-                    /* See http://sylvana.net/jpegcrop/exif_orientation.html*/
-                    if (v_short == 8)
-                    {
-                        rotateAngle = -90;
-                    }
-                    else if (v_short == 6)
-                    {
-                        rotateAngle = 90;
-                    }
+                    // there is data in the desired header tag now get the
+                    // value either by the new or standard exif library method
+#if NEW_LIB_EXIF
+                    exif_entry_get_value(entry, exifvalue, 1023);
+                    value = exifvalue;
+#else
+                    value = exif_entry_get_value(entry);
+#endif
                     break;
                 }
             }
@@ -169 +386 @@
         }
         
         delete [] exifvalue;
-        
-        /*
-        Exiv2::ExifData exifData;
-         int rc = exifData.read(filePath);
-        if (!rc)
-        {
-            Exiv2::ExifKey key = Exiv2::ExifKey("Exif.Image.Orientation");
-            Exiv2::ExifData::iterator pos = exifData.findKey(key);
-            if (pos != exifData.end())
-            {
-                long orientation = pos->toLong();
-                switch (orientation)
-                {
-                    case 6:
-                        rotateAngle = 90;
-                        break;
-                    case 8:
-                        rotateAngle = -90;
-                        break;
-                    default:
-                        rotateAngle = 0;
-                        break;
-                }
-            }
-        }
-        */
-#endif // EXIF_SUPPORT
     }
     catch (...)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR +
                 QString("Failed to extract EXIF headers from '%1'")
-                .arg(filePathString));
+                .arg(filePath));
     }
 
-    return rotateAngle;
+    return value;
 }
+#endif // EXIF_SUPPORT
 
+
 bool GalleryUtil::LoadDirectory(ThumbList& itemList, const QString& dir,
                                 int sortorder, bool recurse,
                                 ThumbHash *itemHash, ThumbGenerator* thumbGen)
 {
-    QString blah = dir;
-    QDir d(blah);
+    QDir d(dir);
     QString currDir = d.absolutePath();
 
     bool isGallery;
@@ -224 +415 @@
     if (thumbGen)
         thumbGen->getThumbcacheDir(currDir);
 
-    QFileInfoList list = d.entryInfoList(GetMediaFilter(),
-                                         QDir::Files | QDir::AllDirs,
-                                         (QDir::SortFlag)sortorder);
+    // these are used more than once so declare them here.
+    QList<QFileInfo> list;
 
+#ifdef EXIF_SUPPORT
+    // check if the directories and files should be
+    // sorted by creation time (exif header information)
+    if (sortorder < 4096 )
+    {
+#endif
+        // sort the usual way
+        list = d.entryInfoList(GetMediaFilter(),
+                            QDir::Files | QDir::AllDirs,
+                            (QDir::SortFlag)sortorder);
+#ifdef EXIF_SUPPORT
+    }
+    else
+    {
+        // fallback sorting order
+        int tempsortorder = QDir::Name | QDir::DirsFirst | QDir::IgnoreCase;
+        list = d.entryInfoList(GetMediaFilter(),
+                            QDir::Files | QDir::AllDirs,
+                            (QDir::SortFlag)tempsortorder);
+
+        // create the thread that will load the exif information from the images
+        DirLoadingThread *dirLoadingThread = new DirLoadingThread();
+        dirLoadingThread->SetData(&list, sortorder);
+
+        // the progress dialog is initially NULL to avoid
+        // setting the progress further down when not needed
+        MythUIProgressDialog *loadingProgressDlg = NULL;
+
+        // show the progress dialog for the loading status when recurse
+        // search is disabled and there are enough files to look for.
+        if (list.count() > 25 && !recurse)
+        {
+            MythScreenStack *m_popupStack = GetMythMainWindow()->GetStack("popup stack");
+            loadingProgressDlg = new MythUIProgressDialog(
+                    QObject::tr("Loading image information"), m_popupStack, "loadingprogressdialog");
+
+            if (loadingProgressDlg->Create())
+            {
+                m_popupStack->AddScreen(loadingProgressDlg, false);
+                loadingProgressDlg->SetTotal(list.count());
+            }
+            else
+            {
+                delete loadingProgressDlg;
+                loadingProgressDlg = NULL;
+            }
+        }
+
+        // start the thread now. it will look for the exif
+        // information and increase the progress counter
+        // that will be read in the while loop below
+        dirLoadingThread->start();
+
+        // update the progress dialog if applicable
+        // or just wait until the thread is done
+        int progress = -1;
+        while (!dirLoadingThread->isFinished())
+        {
+            if (loadingProgressDlg != NULL)
+            {
+                // only update the progress dialog when its needed
+                if (progress != dirLoadingThread->GetProgress())
+                {
+                    progress = dirLoadingThread->GetProgress();
+                    loadingProgressDlg->SetProgress(progress);
+                }
+            }
+
+            usleep(500);
+            qApp->processEvents();
+        }
+
+        // searching for the exif information is done
+        delete dirLoadingThread;
+
+        // close the dialog and clean up
+        if (loadingProgressDlg != NULL)
+            loadingProgressDlg->Close();
+    }
+#endif
+
     if (list.isEmpty())
         return false;
 
-    QFileInfoList::const_iterator it = list.begin();
-    const QFileInfo *fi;
-
     if (thumbGen) 
     {
         thumbGen->cancel();
         thumbGen->setDirectory(currDir, isGallery);
     }
 
+    const QFileInfo *fi;
+    QList<QFileInfo>::const_iterator it = list.begin();
+
     while (it != list.end())
     {
         fi = &(*it);
@@ -275 +546 @@
                 thumbGen->addFile(item->GetName());
         }
     }
-
     return isGallery;
 }
 
-QString GalleryUtil::GetCaption(const QString &filePath)
-{
-    QString caption("");
-
-    try
-    {
-#ifdef EXIF_SUPPORT
-        char *exifvalue = new char[1024];
-        ExifData *data = exif_data_new_from_file(
-            filePath.toLocal8Bit().constData());
-        if (data)
-        {
-            for (int i = 0; i < EXIF_IFD_COUNT; i++)
-            {
-                ExifEntry *entry = exif_content_get_entry (data->ifd[i],
-                                                    EXIF_TAG_USER_COMMENT);
-                if (entry)
-                {
-#if NEW_LIB_EXIF
-                    exif_entry_get_value(entry, exifvalue, 1023);
-                    caption = exifvalue;
-#else
-                    caption = exif_entry_get_value(entry);
-#endif
-                    // Found one, done
-                    if(!caption.isEmpty())
-                       break;
-                }
-
-                entry = exif_content_get_entry (data->ifd[i],
-                                                EXIF_TAG_IMAGE_DESCRIPTION);
-                if (entry)
-                {
-#if NEW_LIB_EXIF
-                    exif_entry_get_value(entry, exifvalue, 1023);
-                    caption = exifvalue;
-#else
-                    caption = exif_entry_get_value(entry);
-#endif
-                    // Found one, done
-                    if(!caption.isEmpty())
-                       break;
-                }
-            }
-            exif_data_free(data);
-        }
-        else
-        {
-           VERBOSE(VB_FILE, LOC_ERR +
-                   QString("Could not load exif data from '%1'")
-                   .arg(filePath));
-        }
-
-        delete [] exifvalue;
-#endif // EXIF_SUPPORT
-    }
-    catch (...)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR +
-                QString("Failed to extract EXIF headers from '%1'")
-                .arg(filePath));
-    }
-
-    return caption;
-}
-
 bool GalleryUtil::Copy(const QFileInfo &src, QFileInfo &dst)
 {
     if (src.isDir())
@@ -748 +952 @@
 
     return true;
 }
+
+
+
+#ifdef EXIF_SUPPORT
+DirLoadingThread::DirLoadingThread()
+{
+    m_progress = 0;
+}
+
+void DirLoadingThread::run()
+{
+    QList<QFileInfo> dirList;
+    QList<QFileInfo> fileList;
+    QList<QFileInfo> fileListExif;
+    QMap<long, QFileInfo> fileListMap;
+
+    const QFileInfo *fi;
+    QFileInfoList::const_iterator it = m_list->begin();
+
+    // go through the list and get the exif time for each file
+    while (it != m_list->end())
+    {
+        fi = &(*it);
+        ++it;
+
+        // get the directories alphabetically in the dirlist and
+        // the files that have time information in the filelistmap.
+        // The files that have no time information go into the filelist.
+        // They will later be combined to get the big list again.
+        if ( fi->isDir() )
+        {
+            dirList.append(*fi);
+        }
+        else
+        {
+            // load the date time from the database to speed up
+            // the loading and sorting time. If the data is not available
+            // add the exif header value in the database.
+            bool ok = false;
+            long dateTime = GalleryUtil::GetDateTimeDB(fi->canonicalFilePath(), &ok);
+
+            if (dateTime == 0 || !ok)
+            {
+                // we dont have a value. try to get it from the exif header
+                dateTime = GalleryUtil::GetDateTime(fi->canonicalFilePath());
+
+                // if we have a value then update the database
+                if ( dateTime > 0 )
+                    GalleryUtil::SetDateTimeDB(fi->canonicalFilePath(), dateTime);
+            }
+
+            // if we have the exif time, place the fileinfo object in the qmap
+            // the map will automatically sort the entries by the time
+            if ( dateTime > 0 )
+                fileListMap.insert(dateTime, *fi);
+            else
+                fileList.append(*fi);
+        }
+
+        usleep(50);
+        m_progress++;
+    }
+
+    // the files with the time information will be placed in
+    // the list in the order specified in the settings screen
+    QMap<long, QFileInfo>::const_iterator i = fileListMap.constBegin();
+    while (i != fileListMap.constEnd())
+    {
+        if ( m_sortorder == 0x1000 )
+            // sort the files oldest first
+            fileListExif.append( i.value() );
+        else
+            // sort the files newest first
+            fileListExif.prepend( i.value() );
+
+        ++i;
+    }
+
+    // the list has already the sorted files with the time
+    // information in it. save the directories in the front
+    // and put the remaining files at the end.
+    m_list->clear();
+    *m_list = m_list->operator +( dirList );
+    *m_list = m_list->operator +( fileListExif );
+    *m_list = m_list->operator +( fileList );
+}
+
+void DirLoadingThread::SetData( QList<QFileInfo> *list, int sortorder )
+{
+    m_list      = list;
+    m_sortorder = sortorder;
+}
+#endif