File indexing completed on 2025-01-05 03:57:11

 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2006-12-09
  * Description : a tread-safe libraw Qt interface
  *
  * SPDX-FileCopyrightText: 2006-2024 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * SPDX-FileCopyrightText: 2006-2013 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * SPDX-FileCopyrightText: 2007-2008 by Guillaume Castagnino <casta at xwing dot info>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  *
  * ============================================================ */
 
 #include "drawdecoder_p.h"
 
 namespace Digikam
 {
 
 DRawDecoder::DRawDecoder()
     : m_cancel(false),
       d       (new Private(this))
 {
 }
 
 DRawDecoder::~DRawDecoder()
 {
     cancel();
     delete d;
 }
 
 void DRawDecoder::cancel()
 {
     m_cancel = true;
 }
 
 bool DRawDecoder::loadRawPreview(QImage& image, const QString& path)
 {
     // In first, try to extract the embedded JPEG preview. Very fast.
 
     bool ret = loadEmbeddedPreview(image, path);
 
     if (ret)
     {
         return true;
     }
 
     // In second, decode and half size of RAW picture. More slow.
 
     return (loadHalfPreview(image, path));
 }
 
 bool DRawDecoder::loadEmbeddedPreview(QImage& image, const QString& path)
 {
     QByteArray imgData;
 
     if (loadEmbeddedPreview(imgData, path))
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "Preview data size:" << imgData.size();
 
         if (image.loadFromData(imgData))
         {
             qCDebug(DIGIKAM_RAWENGINE_LOG) << "Using embedded RAW preview extraction";
 
             return true;
         }
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Failed to load embedded RAW preview";
 
     return false;
 }
 
 bool DRawDecoder::loadEmbeddedPreview(QByteArray& imgData, const QString& path)
 {
     QFileInfo fileInfo(path);
     QString   rawFilesExt = rawFiles();
     QString   ext         = fileInfo.suffix().toUpper();
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: loadEmbeddedPreview from" << path;
 
     LibRaw* const raw = new LibRaw;
 
 #ifdef Q_OS_WIN
 
     int ret           = raw->open_file((const wchar_t*)path.utf16());
 
 #else
 
     int ret           = raw->open_file(path.toUtf8().constData());
 
 #endif
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     return (Private::loadEmbeddedPreview(imgData, raw));
 }
 
 bool DRawDecoder::loadEmbeddedPreview(QByteArray& imgData, const QBuffer& buffer)
 {
     QString rawFilesExt = rawFiles();
     LibRaw* const raw   = new LibRaw;
     QByteArray inData   = buffer.data();
     int ret             = raw->open_buffer((void*) inData.data(), (size_t) inData.size());
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run open_buffer: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     return (Private::loadEmbeddedPreview(imgData, raw));
 }
 
 bool DRawDecoder::loadHalfPreview(QImage& image, const QString& path, bool rotate)
 {
     QFileInfo fileInfo(path);
     QString   rawFilesExt = rawFiles();
     QString   ext         = fileInfo.suffix().toUpper();
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Try to use reduced RAW picture extraction";
 
     LibRaw* const raw                 = new LibRaw;
     raw->imgdata.params.use_auto_wb   = 1;         // Use automatic white balance.
     raw->imgdata.params.use_camera_wb = 1;         // Use camera white balance, if possible.
     raw->imgdata.params.half_size     = 1;         // Half-size color image (3x faster than -q).
 
 #ifdef Q_OS_WIN
 
     int ret                           = raw->open_file((const wchar_t*)path.utf16());
 
 #else
 
     int ret                           = raw->open_file(path.toUtf8().constData());
 
 #endif
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
 
     if (!Private::loadHalfPreview(image, raw, rotate))
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "Failed to get half preview from LibRaw!";
         return false;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Using reduced RAW picture extraction for" << path;
 
     return true;
 }
 
 bool DRawDecoder::loadHalfPreview(QByteArray& imgData, const QString& path)
 {
     QFileInfo fileInfo(path);
     QString   rawFilesExt = rawFiles();
     QString   ext         = fileInfo.suffix().toUpper();
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Try to use reduced RAW picture extraction";
 
     LibRaw* const raw = new LibRaw;
 
 #ifdef Q_OS_WIN
 
     int ret           = raw->open_file((const wchar_t*)path.utf16());
 
 #else
 
     int ret           = raw->open_file(path.toUtf8().constData());
 
 #endif
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run dcraw_process: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     QImage image;
 
     if (!Private::loadHalfPreview(image, raw))
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "DRawDecoder: failed to get half preview: " << libraw_strerror(ret);
 
         return false;
     }
 
     QBuffer buffer(&imgData);
     buffer.open(QIODevice::WriteOnly);
     image.save(&buffer, "JPEG");
 
     return true;
 }
 
 bool DRawDecoder::loadHalfPreview(QByteArray& imgData, const QBuffer& inBuffer)
 {
     QString rawFilesExt = rawFiles();
     LibRaw* const raw   = new LibRaw;
     QByteArray inData   = inBuffer.data();
     int ret             = raw->open_buffer((void*) inData.data(), (size_t) inData.size());
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run dcraw_make_mem_image: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     QImage image;
 
     if (!Private::loadHalfPreview(image, raw))
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "DRawDecoder: failed to get half preview: " << libraw_strerror(ret);
         return false;
     }
 
     QBuffer buffer(&imgData);
     buffer.open(QIODevice::WriteOnly);
     image.save(&buffer, "JPG");
     buffer.close();
 
     return true;
 }
 
 bool DRawDecoder::loadFullImage(QImage& image,
                                 const QString& path,
                                 const DRawDecoderSettings& settings)
 {
     QFileInfo fileInfo(path);
     QString   rawFilesExt = rawFiles();
     QString   ext         = fileInfo.suffix().toUpper();
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Try to load full RAW picture...";
 
     QPointer<DRawDecoder> decoder(new DRawDecoder);
     QByteArray imgData;
     int width, height, rgbmax;
     DRawDecoderSettings prm = settings;
     prm.sixteenBitsImage    = false;
     bool ret                = decoder->decodeRAWImage(path, prm, imgData, width, height, rgbmax);
 
     if (!ret)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "Failed to load full RAW picture";
 
         return false;
     }
 
     uchar* sptr             = (uchar*)imgData.data();
     uchar tmp8[2];
 
     // Set RGB color components.
 
     for (int i = 0 ; i < (width * height) ; ++i)
     {
         // Swap Red and Blue
 
         tmp8[0] = sptr[2];
         tmp8[1] = sptr[0];
         sptr[0] = tmp8[0];
         sptr[2] = tmp8[1];
         sptr   += 3;
     }
 
     image      = QImage(width, height, QImage::Format_ARGB32);
     uint* dptr = reinterpret_cast<uint*>(image.bits());
     sptr       = (uchar*)imgData.data();
 
     for (int i = 0 ; i < (width * height) ; ++i)
     {
         *dptr++ = qRgba(sptr[2], sptr[1], sptr[0], 0xFF);
         sptr   += 3;
     }
 
     qCDebug(DIGIKAM_RAWENGINE_LOG) << "Load full RAW picture done";
 
     return true;
 }
 
 bool DRawDecoder::rawFileIdentify(DRawInfo& identify, const QString& path)
 {
     QFileInfo fileInfo(path);
     QString rawFilesExt  = rawFiles();
     QString ext          = fileInfo.suffix().toUpper();
     identify.isDecodable = false;
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     LibRaw* const raw = new LibRaw;
 
 #ifdef Q_OS_WIN
 
     int ret           = raw->open_file((const wchar_t*)path.utf16());
 
 #else
 
     int ret           = raw->open_file(path.toUtf8().constData());
 
 #endif
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     ret               = raw->adjust_sizes_info_only();
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run adjust_sizes_info_only: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     Private::fillIndentifyInfo(raw, identify);
     raw->recycle();
     delete raw;
 
     return true;
 }
 
 // ----------------------------------------------------------------------------------
 
 bool DRawDecoder::extractRAWData(const QString& filePath,
                                  QByteArray& rawData,
                                  DRawInfo& identify,
                                  unsigned int shotSelect)
 {
     QFileInfo fileInfo(filePath);
     QString rawFilesExt  = rawFiles();
     QString ext          = fileInfo.suffix().toUpper();
     identify.isDecodable = false;
 
     if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
     {
         return false;
     }
 
     if (m_cancel)
     {
         return false;
     }
 
     d->setProgress(0.1);
 
     LibRaw* const raw = new LibRaw;
 
     // Set progress call back function.
 
     raw->set_progress_handler(s_progressCallbackForLibRaw, d);
     raw->set_exifparser_handler(s_exifParserCallbackForLibRaw, d);
 
 #ifdef Q_OS_WIN
 
     int ret           = raw->open_file((const wchar_t*)filePath.utf16());
 
 #else
 
     int ret           = raw->open_file(filePath.toUtf8().constData());
 
 #endif
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     if (m_cancel)
     {
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     d->setProgress(0.3);
 
     raw->imgdata.params.output_bps     = 16;
     raw->imgdata.rawparams.shot_select = shotSelect;
     raw->imgdata.params.user_flip      = -1;
     ret                                = raw->unpack();
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run unpack: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     if (m_cancel)
     {
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     d->setProgress(0.4);
 
     ret = raw->raw2image();
 
     if (ret != LIBRAW_SUCCESS)
     {
         qCDebug(DIGIKAM_RAWENGINE_LOG) << "LibRaw: failed to run raw2image: " << libraw_strerror(ret);
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     if (m_cancel)
     {
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     d->setProgress(0.6);
 
     Private::fillIndentifyInfo(raw, identify);
 
     if (m_cancel)
     {
         raw->recycle();
         delete raw;
 
         return false;
     }
 
     d->setProgress(0.8);
 
     rawData = QByteArray();
 
     if (raw->imgdata.idata.filters == 0)
     {
         rawData.resize((int)((int)raw->imgdata.sizes.iwidth * (int)raw->imgdata.sizes.iheight * (int)raw->imgdata.idata.colors * sizeof(unsigned short)));
 
         unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
 
         for (unsigned int row = 0 ; row < raw->imgdata.sizes.iheight ; ++row)
         {
             for (unsigned int col = 0 ; col < raw->imgdata.sizes.iwidth ; ++col)
             {
                 for (int color = 0 ; color < raw->imgdata.idata.colors ; ++color)
                 {
                     *output = raw->imgdata.image[raw->imgdata.sizes.iwidth*row + col][color];
                     output++;
                 }
             }
         }
     }
     else
     {
         rawData.resize((int)((int)raw->imgdata.sizes.iwidth * (int)raw->imgdata.sizes.iheight * sizeof(unsigned short)));
 
         unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
 
         for (unsigned int row = 0 ; row < raw->imgdata.sizes.iheight ; ++row)
         {
             for (unsigned int col = 0 ; col < raw->imgdata.sizes.iwidth ; ++col)
             {
                 *output = raw->imgdata.image[raw->imgdata.sizes.iwidth*row + col][raw->COLOR(row, col)];
                 output++;
             }
         }
     }
 
     raw->recycle();
     delete raw;
     d->setProgress(1.0);
 
     return true;
 }
 
 bool DRawDecoder::decodeHalfRAWImage(const QString& filePath,
                                      const DRawDecoderSettings& DRawDecoderSettings,
                                      QByteArray& imageData,
                                      int& width,
                                      int& height,
                                      int& rgbmax)
 {
     m_decoderSettings                    = DRawDecoderSettings;
     m_decoderSettings.halfSizeColorImage = true;
 
     return (d->loadFromLibraw(filePath, imageData, width, height, rgbmax));
 }
 
 bool DRawDecoder::decodeRAWImage(const QString& filePath,
                                  const DRawDecoderSettings& DRawDecoderSettings,
                                  QByteArray& imageData,
                                  int& width,
                                  int& height,
                                  int& rgbmax)
 {
     m_decoderSettings = DRawDecoderSettings;
 
     return (d->loadFromLibraw(filePath, imageData, width, height, rgbmax));
 }
 
 bool DRawDecoder::checkToCancelWaitingData()
 {
     return m_cancel;
 }
 
 void DRawDecoder::setWaitingDataProgress(double)
 {
 }
 
 QString DRawDecoder::rawFiles()
 {
     return s_rawFileExtensions();
 }
 
 QStringList DRawDecoder::rawFilesList()
 {
     QString string = rawFiles();
 
     return string.remove(QLatin1String("*.")).split(QLatin1Char(' '));
 }
 
 int DRawDecoder::rawFilesVersion()
 {
     return s_rawFileExtensionsVersion();
 }
 
 QStringList DRawDecoder::supportedCamera()
 {
     QStringList camera;
     const char** const list = LibRaw::cameraList();
 
     for (int i = 0 ; i < LibRaw::cameraCount() ; ++i)
     {
         camera.append(QString::fromUtf8(list[i]));
     }
 
     return camera;
 }
 
 QString DRawDecoder::librawVersion()
 {
     QString simplified = QString::fromLatin1(LIBRAW_VERSION_STR)
                          .section(QLatin1Char('-'), 0, -2);
 
     if (simplified.isEmpty())
     {
         simplified = QString::fromLatin1(LIBRAW_VERSION_STR);
     }
 
     return simplified;
 }
 
 int DRawDecoder::librawUseGomp()
 {
 
 #ifdef LIBRAW_FORCE_OPENMP
 
     return true;
 
 #else
 
 #   ifdef LIBRAW_USE_OPENMP
 
     return true;
 
 #   else
 
     return false;
 
 #   endif
 
 #endif
 
 }
 
 bool DRawDecoder::isRawFile(const QUrl& url)
 {
     QString   rawFilesExt = rawFiles();
     QFileInfo fileInfo(url.toLocalFile());
 
     return (rawFilesExt.toUpper().contains(fileInfo.suffix().toUpper()));
 }
 
 } // namespace Digikam
 
 #include "moc_drawdecoder.cpp"