dimgloader.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2005-06-14
 * Description : DImg image loader interface
 *
 * Copyright (C) 2005      by Renchi Raju <renchi dot raju at gmail dot com>
 * Copyright (C) 2005-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 *
 * This program is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General
 * Public License as published by the Free Software Foundation;
 * either version 2, 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.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_DIMG_LOADER_H
#define DIGIKAM_DIMG_LOADER_H
 
// C++ includes
 
#include <limits>
 
// Qt includes
 
#include <QMap>
#include <QString>
#include <QVariant>
 
// Local includes
 
#include "digikam_debug.h"
#include "digikam_export.h"
#include "dimg.h"
 
namespace Digikam
{
 
class DImgLoaderObserver;
class DMetadata;
 
class DIGIKAM_EXPORT DImgLoader
{
public:
 
    enum LoadFlag
    {
 
        LoadItemInfo     = 1,           
        LoadMetadata     = 2,           
        LoadICCData      = 4,           
 
        LoadImageData    = 8,           
        LoadUniqueHash   = 16,          
        LoadImageHistory = 32,          
 
 
        LoadPreview      = 64,          
 
 
        LoadAll          = LoadItemInfo | LoadMetadata | LoadICCData | LoadImageData | LoadUniqueHash | LoadImageHistory
    };
    Q_DECLARE_FLAGS(LoadFlags, LoadFlag)
 
public:
 
    void setLoadFlags(LoadFlags flags);
 
    virtual ~DImgLoader();
 
    virtual bool load(const QString& filePath, DImgLoaderObserver* const observer)        = 0;
    virtual bool save(const QString& filePath, DImgLoaderObserver* const observer)        = 0;
 
    virtual bool hasLoadedData()                                                    const;
    virtual bool hasAlpha()                                                         const = 0;
    virtual bool sixteenBit()                                                       const = 0;
    virtual bool isReadOnly()                                                       const = 0;
 
    static unsigned char*  new_failureTolerant(size_t unsecureSize);
    static unsigned char*  new_failureTolerant(quint64 w, quint64 h, uint typesPerPixel);
    static unsigned short* new_short_failureTolerant(size_t unsecureSize);
    static unsigned short* new_short_failureTolerant(quint64 w, quint64 h, uint typesPerPixel);
 
    static qint64 checkAllocation(qint64 fullSize);
 
    template <typename Type> static Type* new_failureTolerant(size_t unsecureSize);
    template <typename Type> static Type* new_failureTolerant(quint64 w, quint64 h, uint typesPerPixel);
 
protected:
 
    explicit DImgLoader(DImg* const image);
 
    unsigned char*&         imageData();
    unsigned int&           imageWidth();
    unsigned int&           imageHeight();
 
    bool                    imageHasAlpha()                                         const;
    bool                    imageSixteenBit()                                       const;
 
    quint64                 imageNumBytes()                                         const;
    int                     imageBitsDepth()                                        const;
    int                     imageBytesDepth()                                       const;
 
    void                    imageSetIccProfile(const IccProfile& profile);
    QVariant                imageGetAttribute(const QString& key)                   const;
    void                    imageSetAttribute(const QString& key,
                                              const QVariant& value);
 
    QMap<QString, QString>& imageEmbeddedText()                                     const;
    QString                 imageGetEmbbededText(const QString& key)                const;
    void                    imageSetEmbbededText(const QString& key,
                                                 const QString& text);
 
    void                    loadingFailed();
    bool                    checkExifWorkingColorSpace()                            const;
    void                    purgeExifWorkingColorSpace();
    void                    storeColorProfileInMetadata();
 
    virtual bool            readMetadata(const QString& filePath);
    virtual bool            saveMetadata(const QString& filePath);
    virtual int             granularity(DImgLoaderObserver* const observer, int total, float progressSlice = 1.0F);
 
protected:
 
    DImg*     m_image;
    LoadFlags m_loadFlags;
 
private:
 
    // Disable
    DImgLoader() = delete;
 
private:
 
    Q_DISABLE_COPY(DImgLoader)
};
 
// ---------------------------------------------------------------------------------------------------
 
template <typename Type>
Q_INLINE_TEMPLATE Type* DImgLoader::new_failureTolerant(quint64 w, quint64 h, uint typesPerPixel)
{
    quint64 requested = w * h * (quint64)typesPerPixel;
 
    if (requested >= std::numeric_limits<size_t>::max())
    {
        qCCritical(DIGIKAM_DIMG_LOG) << "Requested memory of" << requested * quint64(sizeof(Type))
                                     << "is larger than size_t supported by platform.";
        return nullptr;
    }
 
    return new_failureTolerant<Type>(requested);
}
 
template <typename Type>
Q_INLINE_TEMPLATE Type* DImgLoader::new_failureTolerant(size_t size)
{
    qint64 res = checkAllocation(size);
 
    switch (res)
    {
        case 0:       // parse failure from supported platform
        {
            return nullptr;
        }
 
        case -1:      // unsupported platform
        {
            // We will try to continue to allocate
            break;
        }
 
        default:     // parse done with success from supported platform
        {
            break;
        }
    }
 
    Type* const reserved = new (std::nothrow) Type[size];
 
    if (!reserved)
    {
        qCCritical(DIGIKAM_DIMG_LOG) << "Failed to allocate chunk of memory of size" << size;
    }
 
    return reserved;
}
 
Q_DECLARE_OPERATORS_FOR_FLAGS(DImgLoader::LoadFlags)
 
} // namespace Digikam
 
#endif // DIGIKAM_DIMG_LOADER_H