Merge lp:~fboucault/gallery-app/fix_exif_orientation into lp:gallery-app

[Florian Boucault]

When rotating pictures during edit, write the EXIF orientation tag with the right type (unsigned short) instead of signed long.
PhotoImageProvider: change its behaviour to only rectify the EXIF orientation tag type when necessary (removes all other behaviours: caching, etc.)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1199
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/1157/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-amd64-ci/85
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/85
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/85/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-i386-ci/85
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/230
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-mako/882
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/590
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21057

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/1157/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1200
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/1158/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-amd64-ci/86
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/86
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/86/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-i386-ci/86
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/232
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-mako/884
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/592
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21067

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/1158/rebuild

review: Needs Fixing (continuous-integration)

[Arthur Mello (artmello)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1202
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/1223/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-amd64-ci/151
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/151
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-armhf-ci/151/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-vivid-i386-ci/151
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-vivid-touch/366
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-touch/1037
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-vivid-armhf/901
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/26618

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/1223/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

1202. By Florian Boucault on 2016-01-13

Merged with trunk

1201. By Florian Boucault on 2015-11-19

Merged with trunk

1200. By Florian Boucault on 2015-06-09

Fix writing of orientation. Should be an unsigned short instead of a long.

1199. By Florian Boucault on 2015-06-09

When rotating pictures during edit, write the EXIF orientation tag with the right type (unsigned short) instead of signed long.
PhotoImageProvider: change its behaviour to only rectify the EXIF orientation tag type when necessary.

=== modified file 'src/gallery-application.cpp'
--- src/gallery-application.cpp	2015-12-16 12:49:12 +0000
+++ src/gallery-application.cpp	2016-01-13 19:01:54 +0000
@@ -220,7 +220,6 @@
     m_view->setTitle("Gallery");
 
     PhotoImageProvider* provider = new PhotoImageProvider();
-    provider->setLogging(true);
     m_view->engine()->addImageProvider(PhotoImageProvider::PROVIDER_ID,
                              provider);
 

=== modified file 'src/photoeditor/photo-image-provider.cpp'
--- src/photoeditor/photo-image-provider.cpp	2015-11-23 17:42:29 +0000
+++ src/photoeditor/photo-image-provider.cpp	2016-01-13 19:01:54 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2014 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,430 +14,69 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authors:
- * Lucas Beeler <[e-mail]>
- * Jim Nelson <[e-mail]>
- * Ugo Riboni <[e-mail]>
+ * Florian Boucault <[e-mail]>
  */
 
 #include "photo-image-provider.h"
-#include "photo-metadata.h"
 
-#include <QDebug>
-#include <QElapsedTimer>
-#include <QImageReader>
-#include <QSize>
-#include <QUrlQuery>
+#include <QtCore/QFileInfo>
+#include <QtGui/QImageReader>
+#include <exiv2/exiv2.hpp>
 
 const char* PhotoImageProvider::PROVIDER_ID = "photo";
-const char* PhotoImageProvider::PROVIDER_ID_SCHEME = "image://photo/";
-
-const long MAX_CACHE_BYTES = 20L * 1024L * 1024L;
-
-/*!
- * \brief PhotoImageProvider::PhotoImageProvider
- */
+const char* EXIF_ORIENTATION_KEY = "Exif.Image.Orientation";
+
 PhotoImageProvider::PhotoImageProvider()
-    : QQuickImageProvider(QQuickImageProvider::Image),
-      m_cachedBytes(0),
-      m_logImageLoading(false),
-      m_emitCacheSignals(false)
+    : QQuickImageProvider(QQuickImageProvider::Image)
 {
 }
 
-/*!
- * \brief PhotoImageProvider::~PhotoImageProvider
- */
 PhotoImageProvider::~PhotoImageProvider()
 {
-    // NOTE: This assumes that we are not receiving requests any longer
-    while (!m_cachingOrder.isEmpty())
-        delete m_cache.value(m_cachingOrder.takeFirst());
 }
 
-#define LOG_IMAGE_STATUS(status) { \
-    if (m_logImageLoading) \
-    loggingStr += status; \
-    }
-
-/*!
- * \brief PhotoImageProvider::requestImage
- * \param id
- * \param size
- * \param requestedSize
- * \return
- */
 QImage PhotoImageProvider::requestImage(const QString& id,
-                                                  QSize* size, const QSize& requestedSize)
+                                        QSize* size, const QSize& requestedSize)
 {
-    // for LOG_IMAGE_STATUS
-    QString loggingStr = "";
-    QElapsedTimer timer;
-    if (m_logImageLoading) timer.start();
-
     QUrl url(id);
-
-    QImage readyImage;
-    uint bytesLoaded = 0;
-
-    CachedImage* cachedImage = claimCachedImageEntry(id, loggingStr);
-    Q_ASSERT(cachedImage != NULL);
-
-    readyImage = fetchCachedImage(cachedImage, requestedSize, &bytesLoaded,
-                                  loggingStr);
-    if (readyImage.isNull())
-        LOG_IMAGE_STATUS("load-failure ");
-
-    releaseCachedImageEntry(cachedImage, bytesLoaded);
-
-    if (m_logImageLoading) {
-        if (bytesLoaded > 0) {
-            qDebug("%s %s req:%dx%d ret:%dx%d cache:%ldb/%d loaded:%db time:%lldms", qPrintable(loggingStr),
-                   qPrintable(id), requestedSize.width(), requestedSize.height(), readyImage.width(),
-                   readyImage.height(), m_cachedBytes, m_cache.size(), bytesLoaded,
-                   timer.elapsed());
-        } else {
-            qDebug("%s %s req:%dx%d ret:%dx%d cache:%ldb/%d time:%lldms", qPrintable(loggingStr),
-                   qPrintable(id), requestedSize.width(), requestedSize.height(), readyImage.width(),
-                   readyImage.height(), m_cachedBytes, m_cache.size(), timer.elapsed());
-        }
-    }
-
-    if (size != NULL)
-        *size = readyImage.size();
-
-    return readyImage;
-}
-
-/*!
- * \brief PhotoImageProvider::setLogging enables to print photo loading
- * times to stout
- * \param enableLogging
- */
-void PhotoImageProvider::setLogging(bool enableLogging)
-{
-    m_logImageLoading = enableLogging;
-}
-
-/*!
- * \brief PhotoImageProvider::setEmitCacheSignals enabled emitting signals to
- * track the status of the internal cache.
- * \param emitCacheSignals
- */
-void PhotoImageProvider::setEmitCacheSignals(bool emitCacheSignals)
-{
-    m_emitCacheSignals = emitCacheSignals;
-}
-
-/*!
- * \brief PhotoImageProvider::claim_cached_image_entry
- * Returns a CachedImage with an inUseCount > 0, meaning it cannot be
- * removed from the cache until released
- * \param id
- * \param loggingStr
- * \return
- */
-PhotoImageProvider::CachedImage* PhotoImageProvider::claimCachedImageEntry(
-        const QString& id, QString& loggingStr)
-{
-    // lock the cache table and retrieve the element for the cached image; if
-    // not found, create one as a placeholder
-    m_cacheMutex.lock();
-
-    CachedImage* cachedImage = m_cache.value(id, NULL);
-    if (cachedImage != NULL) {
-        // remove CachedImage before prepending to FIFO
-        m_cachingOrder.removeOne(id);
-    } else {
-        cachedImage = new CachedImage(id);
-        m_cache.insert(id, cachedImage);
-        LOG_IMAGE_STATUS("new-cache-entry ");
-    }
-
-    // add to front of FIFO
-    m_cachingOrder.prepend(id);
-
-    // should be the same size, always
-    Q_ASSERT(m_cache.size() == m_cachingOrder.size());
-
-    // claim the CachedImage *while cacheMutex_ is locked* ... this prevents the
-    // CachedImage from being removed from the cache while its being filled
-    cachedImage->cleanCount++;
-
-    m_cacheMutex.unlock();
-
-    return cachedImage;
-}
-
-/*!
- * \brief PhotoImageProvider::fetch_cached_image Inspects and loads a proper image
- * Inspects and loads a proper image for this request into the CachedImage
- * \param cachedImage
- * \param requestedSize
- * \param bytesLoaded
- * \param loggingStr
- * \return
- */
-QImage PhotoImageProvider::fetchCachedImage(CachedImage *cachedImage,
-                                            const QSize& requestedSize,
-                                            uint* bytesLoaded,
-                                            QString& loggingStr)
-{
-    Q_ASSERT(cachedImage != NULL);
-
-    QString file = QUrl(cachedImage->id).path();
-
-    // the final image returned to the user
-    QImage readyImage;
-    Q_ASSERT(readyImage.isNull());
-
-    // lock the cached image itself to access
-    cachedImage->imageMutex.lock();
-
-    // Depending on the file system used the last modified date of a file
-    // might have a really low resolution (2s for FAT32, 1s for ext3). Therefore
-    // we have to take the worse case and accept that there will be additional cache
-    // misses when an image is requested again just after it has been cached.
-    // There is no alternative to this other than accepting false cache hits, which
-    // would result in bugs in the application.
-    QFileInfo photoFile(file);
-    QDateTime fileLastModified = photoFile.lastModified();
-    fileLastModified = fileLastModified.addSecs(2);
-
-    // if image is available, see if a fit
-    if (cachedImage->isCacheHit(requestedSize)) {
-        if (cachedImage->cachedAt > fileLastModified) {
-            readyImage = cachedImage->image;
-            LOG_IMAGE_STATUS("cache-hit ");
-            if (m_emitCacheSignals) Q_EMIT cacheHit(cachedImage->id, requestedSize);
-        } else {
-            // if the file was modified after the image was cached, reload it
-            LOG_IMAGE_STATUS("cache-stale ");
-            if (m_emitCacheSignals) cacheMiss(cachedImage->id, requestedSize, true);
-        }
-    } else {
-        LOG_IMAGE_STATUS("cache-miss ");
-        if (m_emitCacheSignals) cacheMiss(cachedImage->id, requestedSize, false);
-    }
-
-    if (bytesLoaded != NULL)
-        *bytesLoaded = 0;
-
-    // if unavailable or stale, load now
-    if (readyImage.isNull()) {
-        QImageReader reader(file);
-
-        // load file's original size
-        QSize fullSize = reader.size();
-        QSize loadSize(fullSize);
-
-        // use scaled load-and-decode if size has been requested
-        if (fullSize.isValid() && (requestedSize.width() > 0 || requestedSize.height() > 0)) {
-            loadSize.scale(requestedSize, Qt::KeepAspectRatio);
-            if (loadSize.width() > fullSize.width() || loadSize.height() > fullSize.height())
-                loadSize = fullSize;
-        }
-
-        if (loadSize != fullSize) {
-            LOG_IMAGE_STATUS("scaled-load ");
-
-            // configure reader for scaled load-and-decode
-            reader.setScaledSize(loadSize);
-        } else {
-            LOG_IMAGE_STATUS("full-load ");
-        }
-
-        readyImage = reader.read();
-        if (!readyImage.isNull()) {
-            if (!fullSize.isValid())
-                fullSize = readyImage.size();
-
-            Orientation orientation = TOP_LEFT_ORIGIN;
-            std::unique_ptr<PhotoMetadata> metadata(PhotoMetadata::fromFile(file));
-            if (metadata.get() != NULL)
-                orientation = metadata->orientation();
-
-            // rotate image if not TOP LEFT
-            if (orientation != TOP_LEFT_ORIGIN)  {
-                readyImage = readyImage.transformed(
-                            OrientationCorrection::fromOrientation(orientation).toTransform());
+    QString filePath = url.path();
+
+    QFileInfo fileInfo(filePath);
+    QString original = fileInfo.path() + "/.original/" + fileInfo.fileName();
+    if (QFileInfo::exists(original)) {
+        Exiv2::Image::AutoPtr exivImage;
+        try {
+            exivImage = Exiv2::ImageFactory::open(filePath.toStdString());
+            exivImage->readMetadata();
+            Exiv2::ExifData& exifData = exivImage->exifData();
+            if (exifData[EXIF_ORIENTATION_KEY].typeId() == Exiv2::signedLong) {
+                exifData[EXIF_ORIENTATION_KEY] = (Exiv2::UShortValue)exifData[EXIF_ORIENTATION_KEY].toLong();
+                exivImage->writeMetadata();
             }
-
-            // If we are reloading an image, the cache total byte count will be the
-            // difference in size between the old image and the new one (could be negative, for
-            // example in cases of cropping).
-            // If we are not reloading, then the current count will be zero and the total byte
-            // count will be the full size of the newly loaded image.
-            int currentByteCount = readyImage.byteCount();
-
-            cachedImage->storeImage(readyImage, fullSize, orientation);
-            if (m_emitCacheSignals) Q_EMIT cacheAdd(cachedImage->id, requestedSize, loadSize);
-
-            if (bytesLoaded != NULL)
-                *bytesLoaded = readyImage.byteCount() - currentByteCount;
-        } else {
-            qDebug("Unable to load %s: %s", qPrintable(cachedImage->id),
-                   qPrintable(reader.errorString()));
-        }
-    } else {
-        // if the image comes from the cache and the requested size is smaller
-        // than what we cached, scale the image before returning it
-        if (requestedSize.isValid()) {
-            readyImage = readyImage.scaled(requestedSize, Qt::KeepAspectRatio);
-        }
-    }
-
-    cachedImage->imageMutex.unlock();
-
-    return readyImage;
-}
-
-/*!
- * \brief PhotoImageProvider::release_cached_image_entry
- * Releases a CachedImage to the cache; takes its bytes loaded (0 if nothing
- * was loaded) and returns the current cached byte total
- * \param cachedImage
- * \param bytesLoaded
- * \param currentCacheEntries
- */
-void PhotoImageProvider::releaseCachedImageEntry
-(CachedImage *cachedImage, uint bytesLoaded)
-{
-    Q_ASSERT(cachedImage != NULL);
-
-    // update total cached bytes and remove excess bytes
-    m_cacheMutex.lock();
-
-    m_cachedBytes += bytesLoaded;
-
-    // update the CachedImage use count and byte count inside of *cachedMutex_ lock*
-    Q_ASSERT(cachedImage->cleanCount > 0);
-    cachedImage->cleanCount--;
-    if (bytesLoaded != 0)
-        cachedImage->byteCount = bytesLoaded;
-
-    // trim the cache
-    QList<CachedImage*> dropList;
-    while (m_cachedBytes > MAX_CACHE_BYTES && !m_cachingOrder.isEmpty()) {
-        QString droppedFile = m_cachingOrder.takeLast();
-
-        CachedImage* droppedCachedImage = m_cache.value(droppedFile);
-        Q_ASSERT(droppedCachedImage != NULL);
-
-        // for simplicity, stop when dropped item is in use or doesn't contain
-        // an image (which it won't for too long) ... will clean up next time
-        // through
-        if (droppedCachedImage->cleanCount > 0) {
-            m_cachingOrder.append(droppedFile);
-
-            break;
-        }
-
-        // remove from map
-        m_cache.remove(droppedFile);
-
-        // decrement total cached size
-        m_cachedBytes -= droppedCachedImage->byteCount;
-        Q_ASSERT(m_cachedBytes >= 0);
-
-        dropList.append(droppedCachedImage);
-    }
-
-    // coherency is good
-    Q_ASSERT(m_cache.size() == m_cachingOrder.size());
-
-    m_cacheMutex.unlock();
-
-    // perform actual deletion outside of lock
-    while (!dropList.isEmpty())
-        delete dropList.takeFirst();
-}
-
-/*!
- * \brief PhotoImageProvider::orientSize
- * \param size
- * \param orientation
- * \return
- */
-QSize PhotoImageProvider::orientSize(const QSize& size, Orientation orientation)
-{
-    switch (orientation) {
-    case LEFT_TOP_ORIGIN:
-    case RIGHT_TOP_ORIGIN:
-    case RIGHT_BOTTOM_ORIGIN:
-    case LEFT_BOTTOM_ORIGIN:
-        return QSize(size.height(), size.width());
-        break;
-
-    default:
-        // no change
-        return size;
-    }
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::CachedImage
- * \param id the full URI of the image
- * \param fileName the filename for the URI (the file itself)
- */
-PhotoImageProvider::CachedImage::CachedImage(const QString& id)
-    : id(id), orientation(TOP_LEFT_ORIGIN), cleanCount(0), byteCount(0)
-{
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::storeImage
- * Importand: the following should only be called when imageMutex_ is locked
- * \param image
- * \param fullSize
- * \param orientation
- */
-void PhotoImageProvider::CachedImage::storeImage(const QImage& newImage,
-                                                           const QSize& newFullSize,
-                                                           Orientation newOrientation)
-{
-    image = newImage;
-    fullSize = orientSize(newFullSize, orientation);
-    orientation = newOrientation;
-    cachedAt = QDateTime::currentDateTime();
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isReady
- * \return
- */
-bool PhotoImageProvider::CachedImage::isReady() const
-{
-    return !image.isNull();
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isFullSized
- * \return
- */
-bool PhotoImageProvider::CachedImage::isFullSized() const
-{
-    return isReady() && (image.size() == fullSize);
-}
-
-/*!
- * \brief PhotoImageProvider::CachedImage::isCacheHit
- * \param requestedSize
- * \return
- */
-bool PhotoImageProvider::CachedImage::isCacheHit(const QSize& requestedSize) const
-{
-    if (!isReady())
-        return false;
-
-    if (isFullSized())
-        return true;
-
-    QSize properRequestedSize = orientSize(requestedSize, orientation);
-
-    if ((properRequestedSize.width() != 0 && image.width() >= properRequestedSize.width())
-            || (properRequestedSize.height() != 0 && image.height() >= properRequestedSize.height())) {
-        return true;
-    }
-
-    return false;
+        } catch (Exiv2::AnyError& e) {
+        }
+    }
+
+    QImageReader reader(filePath);
+    QSize fullSize = reader.size();
+    QSize loadSize(fullSize);
+
+    if (fullSize.isValid() && (requestedSize.width() > 0 || requestedSize.height() > 0)) {
+        loadSize.scale(requestedSize, Qt::KeepAspectRatio);
+        if (loadSize.width() > fullSize.width() || loadSize.height() > fullSize.height()) {
+            loadSize = fullSize;
+        }
+    }
+
+    if (loadSize != fullSize) {
+        reader.setScaledSize(loadSize);
+    }
+
+    QImage image = reader.read();
+
+    if (size != NULL) {
+        *size = image.size();
+    }
+
+    return image;
 }

=== modified file 'src/photoeditor/photo-image-provider.h'
--- src/photoeditor/photo-image-provider.h	2015-02-26 20:28:06 +0000
+++ src/photoeditor/photo-image-provider.h	2016-01-13 19:01:54 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2014 Canonical Ltd
+ * Copyright (C) 2015 Canonical Ltd
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
@@ -14,111 +14,27 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authors:
- * Lucas Beeler <[e-mail]>
- * Jim Nelson <[e-mail]>
- * Ugo Riboni <[e-mail]>
-*/
+ * Florian Boucault <[e-mail]>
+ */
 
 #ifndef PHOTO_IMAGE_PROVIDER_H_
 #define PHOTO_IMAGE_PROVIDER_H_
 
-// util
-#include "orientation.h"
-
-#include <QDateTime>
-#include <QFileInfo>
-#include <QImage>
-#include <QMap>
-#include <QMutex>
-#include <QObject>
-#include <QQuickImageProvider>
-#include <QSize>
-#include <QString>
-#include <QUrl>
-
-/*!
- * We use a custom image provider for the following reasons:
- *
- * 1. QML's image loader does not respect EXIF orientation.  This provider will
- *    rotate and mirror the image as necessary.
- *
- * 2. QML's image caching appears to be directly related to image size (scaling)
- *    which leads to thrashing when animating a thumbnail or loading images at
- *    various sizes.
- *    The strategy here is to cache the largest requested size of the image
- *    and downscale it if smaller versions are requested. This minimizes
- *    expensive JPEG load-and-decodes.
- *
- * 3. Logging allows for monitoring of all image I/O, useful when debugging and
- *    optimizing, and signals can be emitted to monitor and test cache operation.
- *
- * 4. The QML cache does not check if a file has been modified on disk after it
- *    was cached, but our cache does. You should always set Image.cache to false
- *    when loading images from this provider in QML.
- */
-class PhotoImageProvider : public QObject, public QQuickImageProvider
+#include <QtQuick/QQuickImageProvider>
+#include <QtGui/QImage>
+#include <QtCore/QString>
+#include <QtCore/QSize>
+
+class PhotoImageProvider : public QQuickImageProvider
 {
-    Q_OBJECT
-
 public:
     static const char* PROVIDER_ID;
-    static const char* PROVIDER_ID_SCHEME;
 
     PhotoImageProvider();
     virtual ~PhotoImageProvider();
 
     virtual QImage requestImage(const QString& id, QSize* size,
                                 const QSize& requestedSize);
-
-    void setLogging(bool enableLogging);
-    void setEmitCacheSignals(bool emitCacheSignals);
-
-Q_SIGNALS:
-    void cacheHit(QString id, QSize size);
-    void cacheMiss(QString id, QSize size, bool wasStale);
-    void cacheAdd(QString id, QSize size, QSize cachedSize);
-
-private:
-    class CachedImage {
-    public:
-        const QString id;
-        QMutex imageMutex;
-
-        // these fields should only be accessed when imageMutex_ is locked
-        QImage image;
-        QSize fullSize;
-        Orientation orientation;
-        QDateTime cachedAt;
-
-        // the following should only be accessed when cacheMutex_ is locked; the
-        // counter controls removing a CachedImage entry from the cache table
-        int cleanCount;
-        uint byteCount;
-
-        CachedImage(const QString& id);
-
-        void storeImage(const QImage& newImage, const QSize& newFullSize,
-                        Orientation newOrientation);
-        bool isFullSized() const;
-        bool isReady() const;
-        bool isCacheHit(const QSize& requestedSize) const;
-    };
-
-    QMap<QString, CachedImage*> m_cache;
-    QList<QString> m_cachingOrder;
-    QMutex m_cacheMutex;
-    long m_cachedBytes;
-    bool m_logImageLoading;
-    bool m_emitCacheSignals;
-
-    static QSize orientSize(const QSize& size, Orientation orientation);
-
-    CachedImage* claimCachedImageEntry(const QString& id, QString& loggingStr);
-
-    QImage fetchCachedImage(CachedImage* cachedImage, const QSize& requestedSize,
-                              uint* bytesLoaded, QString& loggingStr);
-
-    void releaseCachedImageEntry(CachedImage* cachedImage, uint bytesLoaded);
 };
 
 #endif // PHOTO_IMAGE_PROVIDER_H_

=== modified file 'src/photoeditor/photo-metadata.cpp'
--- src/photoeditor/photo-metadata.cpp	2015-05-06 20:15:54 +0000
+++ src/photoeditor/photo-metadata.cpp	2016-01-13 19:01:54 +0000
@@ -219,7 +219,7 @@
 {
     Exiv2::ExifData& exif_data = m_image->exifData();
 
-    exif_data[EXIF_ORIENTATION_KEY] = orientation;
+    exif_data[EXIF_ORIENTATION_KEY] = (Exiv2::UShortValue)orientation;
 
     if (!m_keysPresent.contains(EXIF_ORIENTATION_KEY))
         m_keysPresent.insert(EXIF_ORIENTATION_KEY);