• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdegraphics API Reference
  • KDE Home
  • Contact Us
 

libs/libkdcraw/libkdcraw

  • sources
  • kde-4.14
  • kdegraphics
  • libs
  • libkdcraw
  • libkdcraw
kdcraw.cpp
Go to the documentation of this file.
1 
30 #include "kdcraw.moc"
31 #include "kdcraw_p.h"
32 
33 // Qt includes
34 
35 #include <QFile>
36 #include <QFileInfo>
37 #include <QStringList>
38 
39 // KDE includes
40 
41 #include <klibloader.h>
42 
43 // LibRaw includes
44 
45 #include <libraw_version.h>
46 
47 #ifdef LIBRAW_HAS_CONFIG
48 #include <libraw_config.h>
49 #endif
50 
51 // Local includes
52 
53 #include "version.h"
54 #include "rawfiles.h"
55 
56 static const KCatalogLoader loader("libkdcraw");
57 
58 namespace KDcrawIface
59 {
60 
61 KDcraw::KDcraw()
62  : d(new Private(this))
63 {
64  m_cancel = false;
65 }
66 
67 KDcraw::~KDcraw()
68 {
69  cancel();
70  delete d;
71 }
72 
73 QString KDcraw::version()
74 {
75  return QString(kdcraw_version);
76 }
77 
78 void KDcraw::cancel()
79 {
80  m_cancel = true;
81 }
82 
83 bool KDcraw::loadRawPreview(QImage& image, const QString& path)
84 {
85  // In first, try to extract the embedded JPEG preview. Very fast.
86  bool ret = loadEmbeddedPreview(image, path);
87 
88  if (ret)
89  return true;
90 
91  // In second, decode and half size of RAW picture. More slow.
92  return (loadHalfPreview(image, path));
93 }
94 
95 bool KDcraw::loadEmbeddedPreview(QImage& image, const QString& path)
96 {
97  QByteArray imgData;
98 
99  if ( loadEmbeddedPreview(imgData, path) )
100  {
101  kDebug() << "Preview data size:" << imgData.size();
102 
103  if (image.loadFromData( imgData ))
104  {
105  kDebug() << "Using embedded RAW preview extraction";
106  return true;
107  }
108  }
109 
110  kDebug() << "Failed to load embedded RAW preview";
111  return false;
112 }
113 
114 bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QString& path)
115 {
116  QFileInfo fileInfo(path);
117  QString rawFilesExt(rawFiles());
118  QString ext = fileInfo.suffix().toUpper();
119 
120  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
121  return false;
122 
123  LibRaw raw;
124 
125  int ret = raw.open_file(QFile::encodeName(path));
126 
127  if (ret != LIBRAW_SUCCESS)
128  {
129  kDebug() << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
130  raw.recycle();
131  return false;
132  }
133 
134  return (Private::loadEmbeddedPreview(imgData, raw));
135 }
136 
137 bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QBuffer& buffer)
138 {
139  QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
140  LibRaw raw;
141 
142  QByteArray inData = buffer.data();
143  int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
144 
145  if (ret != LIBRAW_SUCCESS)
146  {
147  kDebug() << "LibRaw: failed to run open_buffer: " << libraw_strerror(ret);
148  raw.recycle();
149  return false;
150  }
151 
152  return (Private::loadEmbeddedPreview(imgData, raw));
153 }
154 
155 bool KDcraw::loadHalfPreview(QImage& image, const QString& path)
156 {
157  QFileInfo fileInfo(path);
158  QString rawFilesExt(rawFiles());
159  QString ext = fileInfo.suffix().toUpper();
160 
161  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
162  return false;
163 
164  kDebug() << "Try to use reduced RAW picture extraction";
165 
166  LibRaw raw;
167  raw.imgdata.params.use_auto_wb = 1; // Use automatic white balance.
168  raw.imgdata.params.use_camera_wb = 1; // Use camera white balance, if possible.
169  raw.imgdata.params.half_size = 1; // Half-size color image (3x faster than -q).
170 
171  int ret = raw.open_file(QFile::encodeName(path));
172 
173  if (ret != LIBRAW_SUCCESS)
174  {
175  kDebug() << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
176  raw.recycle();
177  return false;
178  }
179 
180 
181  if(!Private::loadHalfPreview(image, raw))
182  {
183  kDebug() << "Failed to get half preview from LibRaw!";
184  return false;
185  }
186 
187  kDebug() << "Using reduced RAW picture extraction";
188 
189  return true;
190 }
191 
192 bool KDcraw::loadHalfPreview(QByteArray& imgData, const QString& path)
193 {
194  QFileInfo fileInfo(path);
195  QString rawFilesExt(rawFiles());
196  QString ext = fileInfo.suffix().toUpper();
197 
198  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
199  return false;
200 
201  kDebug() << "Try to use reduced RAW picture extraction";
202 
203  LibRaw raw;
204  int ret = raw.open_file(QFile::encodeName(path));
205 
206  if (ret != LIBRAW_SUCCESS)
207  {
208  kDebug() << "LibRaw: failed to run dcraw_process: " << libraw_strerror(ret);
209  raw.recycle();
210  return false;
211  }
212 
213  QImage image;
214 
215  if (!Private::loadHalfPreview(image, raw))
216  {
217  kDebug() << "KDcraw: failed to get half preview: " << libraw_strerror(ret);
218  return false;
219  }
220 
221  QBuffer buffer(&imgData);
222  buffer.open(QIODevice::WriteOnly);
223  image.save(&buffer, "JPEG");
224 
225  return true;
226 }
227 
228 bool KDcraw::loadHalfPreview(QByteArray& imgData, const QBuffer& inBuffer)
229 {
230  QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
231  LibRaw raw;
232 
233  QByteArray inData = inBuffer.data();
234  int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
235 
236  if (ret != LIBRAW_SUCCESS)
237  {
238  kDebug() << "LibRaw: failed to run dcraw_make_mem_image: " << libraw_strerror(ret);
239  raw.recycle();
240  return false;
241  }
242 
243  QImage image;
244 
245  if (!Private::loadHalfPreview(image, raw))
246  {
247  kDebug() << "KDcraw: failed to get half preview: " << libraw_strerror(ret);
248  return false;
249  }
250 
251  QBuffer buffer(&imgData);
252  buffer.open(QIODevice::WriteOnly);
253  image.save(&buffer, "JPG");
254 
255  return true;
256 }
257 
258 bool KDcraw::loadFullImage(QImage& image, const QString& path, const RawDecodingSettings& settings)
259 {
260  QFileInfo fileInfo(path);
261  QString rawFilesExt(rawFiles());
262  QString ext = fileInfo.suffix().toUpper();
263 
264  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
265  return false;
266 
267  kDebug() << "Try to load full RAW picture...";
268 
269  RawDecodingSettings prm = settings;
270  prm.sixteenBitsImage = false;
271  QByteArray imgData;
272  int width, height, rgbmax;
273 
274  KDcraw decoder;
275  bool ret = decoder.decodeRAWImage(path, prm, imgData, width, height, rgbmax);
276 
277  if (!ret)
278  {
279  kDebug() << "Failled to load full RAW picture";
280  return false;
281  }
282 
283  uchar* sptr = (uchar*)imgData.data();
284  uchar tmp8[2];
285 
286  // Set RGB color components.
287  for (int i = 0 ; i < width * height ; ++i)
288  {
289  // Swap Red and Blue
290  tmp8[0] = sptr[2];
291  tmp8[1] = sptr[0];
292  sptr[0] = tmp8[0];
293  sptr[2] = tmp8[1];
294 
295  sptr += 3;
296  }
297 
298  image = QImage(width, height, QImage::Format_ARGB32);
299  uint* dptr = reinterpret_cast<uint*>(image.bits());
300  sptr = (uchar*)imgData.data();
301 
302  for (int i = 0 ; i < width * height ; ++i)
303  {
304  *dptr++ = qRgba(sptr[2], sptr[1], sptr[0], 0xFF);
305  sptr += 3;
306  }
307 
308  kDebug() << "Load full RAW picture done";
309 
310  return true;
311 }
312 
313 bool KDcraw::rawFileIdentify(DcrawInfoContainer& identify, const QString& path)
314 {
315  QFileInfo fileInfo(path);
316  QString rawFilesExt(rawFiles());
317  QString ext = fileInfo.suffix().toUpper();
318  identify.isDecodable = false;
319 
320  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
321  return false;
322 
323  LibRaw raw;
324 
325  int ret = raw.open_file(QFile::encodeName(path));
326 
327  if (ret != LIBRAW_SUCCESS)
328  {
329  kDebug() << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
330  raw.recycle();
331  return false;
332  }
333 
334  ret = raw.adjust_sizes_info_only();
335 
336  if (ret != LIBRAW_SUCCESS)
337  {
338  kDebug() << "LibRaw: failed to run adjust_sizes_info_only: " << libraw_strerror(ret);
339  raw.recycle();
340  return false;
341  }
342 
343  Private::fillIndentifyInfo(&raw, identify);
344  raw.recycle();
345  return true;
346 }
347 
348 // ----------------------------------------------------------------------------------
349 
350 bool KDcraw::extractRAWData(const QString& filePath, QByteArray& rawData, DcrawInfoContainer& identify, unsigned int shotSelect)
351 {
352  QFileInfo fileInfo(filePath);
353  QString rawFilesExt(rawFiles());
354  QString ext = fileInfo.suffix().toUpper();
355  identify.isDecodable = false;
356 
357  if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
358  return false;
359 
360  if (m_cancel)
361  return false;
362 
363  d->setProgress(0.1);
364 
365  LibRaw raw;
366  // Set progress call back function.
367  raw.set_progress_handler(callbackForLibRaw, d);
368 
369  int ret = raw.open_file(QFile::encodeName(filePath));
370 
371  if (ret != LIBRAW_SUCCESS)
372  {
373  kDebug() << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
374  raw.recycle();
375  return false;
376  }
377 
378  if (m_cancel)
379  {
380  raw.recycle();
381  return false;
382  }
383 
384  d->setProgress(0.3);
385 
386  raw.imgdata.params.output_bps = 16;
387  raw.imgdata.params.shot_select = shotSelect;
388  ret = raw.unpack();
389 
390  if (ret != LIBRAW_SUCCESS)
391  {
392  kDebug() << "LibRaw: failed to run unpack: " << libraw_strerror(ret);
393  raw.recycle();
394  return false;
395  }
396 
397  if (m_cancel)
398  {
399  raw.recycle();
400  return false;
401  }
402 
403  d->setProgress(0.4);
404 
405  ret = raw.raw2image();
406 
407  if (ret != LIBRAW_SUCCESS)
408  {
409  kDebug() << "LibRaw: failed to run raw2image: " << libraw_strerror(ret);
410  raw.recycle();
411  return false;
412  }
413 
414  if (m_cancel)
415  {
416  raw.recycle();
417  return false;
418  }
419 
420  d->setProgress(0.6);
421 
422  Private::fillIndentifyInfo(&raw, identify);
423 
424  if (m_cancel)
425  {
426  raw.recycle();
427  return false;
428  }
429 
430  d->setProgress(0.8);
431 
432  rawData = QByteArray();
433 
434  if (raw.imgdata.idata.filters == 0)
435  {
436  rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * raw.imgdata.idata.colors * sizeof(unsigned short)));
437 
438  unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
439 
440  for (unsigned int row = 0; row < raw.imgdata.sizes.iheight; row++)
441  {
442  for (unsigned int col = 0; col < raw.imgdata.sizes.iwidth; col++)
443  {
444  for (int color = 0; color < raw.imgdata.idata.colors; color++)
445  {
446  *output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][color];
447  output++;
448  }
449  }
450  }
451  }
452  else
453  {
454  rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * sizeof(unsigned short)));
455 
456  unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
457 
458  for (uint row = 0; row < raw.imgdata.sizes.iheight; row++)
459  {
460  for (uint col = 0; col < raw.imgdata.sizes.iwidth; col++)
461  {
462  *output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][raw.COLOR(row, col)];
463  output++;
464  }
465  }
466  }
467 
468  raw.recycle();
469  d->setProgress(1.0);
470 
471  return true;
472 }
473 
474 bool KDcraw::decodeHalfRAWImage(const QString& filePath, const RawDecodingSettings& rawDecodingSettings,
475  QByteArray& imageData, int& width, int& height, int& rgbmax)
476 {
477  m_rawDecodingSettings = rawDecodingSettings;
478  m_rawDecodingSettings.halfSizeColorImage = true;
479  return (d->loadFromLibraw(filePath, imageData, width, height, rgbmax));
480 }
481 
482 bool KDcraw::decodeRAWImage(const QString& filePath, const RawDecodingSettings& rawDecodingSettings,
483  QByteArray& imageData, int& width, int& height, int& rgbmax)
484 {
485  m_rawDecodingSettings = rawDecodingSettings;
486  return (d->loadFromLibraw(filePath, imageData, width, height, rgbmax));
487 }
488 
489 bool KDcraw::checkToCancelWaitingData()
490 {
491  return m_cancel;
492 }
493 
494 void KDcraw::setWaitingDataProgress(double)
495 {
496 }
497 
498 const char* KDcraw::rawFiles()
499 {
500  return raw_file_extentions;
501 }
502 
503 QStringList KDcraw::rawFilesList()
504 {
505  QString string = QString::fromLatin1(rawFiles());
506  return string.remove("*.").split(' ');
507 }
508 
509 int KDcraw::rawFilesVersion()
510 {
511  return raw_file_extensions_version;
512 }
513 
514 QStringList KDcraw::supportedCamera()
515 {
516  QStringList camera;
517  const char** const list = LibRaw::cameraList();
518 
519  for (int i = 0; i < LibRaw::cameraCount(); i++)
520  camera.append(list[i]);
521 
522  return camera;
523 }
524 
525 QString KDcraw::librawVersion()
526 {
527  return QString(LIBRAW_VERSION_STR).remove("-Release");
528 }
529 
530 int KDcraw::librawUseGomp()
531 {
532 #ifdef LIBRAW_HAS_CONFIG
533 # ifdef LIBRAW_USE_OPENMP
534  return true;
535 # else
536  return false;
537 # endif
538 #else
539  return -1;
540 #endif
541 }
542 
543 int KDcraw::librawUseRawSpeed()
544 {
545 #ifdef LIBRAW_HAS_CONFIG
546 # ifdef LIBRAW_USE_RAWSPEED
547  return true;
548 # else
549  return false;
550 # endif
551 #else
552  return -1;
553 #endif
554 }
555 
556 int KDcraw::librawUseGPL2DemosaicPack()
557 {
558 #ifdef LIBRAW_HAS_CONFIG
559 # ifdef LIBRAW_USE_DEMOSAIC_PACK_GPL2
560  return true;
561 # else
562  return false;
563 # endif
564 #else
565  return -1;
566 #endif
567 }
568 
569 int KDcraw::librawUseGPL3DemosaicPack()
570 {
571 #ifdef LIBRAW_HAS_CONFIG
572 # ifdef LIBRAW_USE_DEMOSAIC_PACK_GPL3
573  return true;
574 # else
575  return false;
576 # endif
577 #else
578  return -1;
579 #endif
580 }
581 
582 } // namespace KDcrawIface
KDcrawIface::RawDecodingSettings::halfSizeColorImage
bool halfSizeColorImage
Half-size color image decoding (twice as fast as "enableRAWQuality").
Definition: rawdecodingsettings.h:213
QImage::loadFromData
bool loadFromData(const uchar *data, int len, const char *format)
KDcrawIface::KDcraw::librawVersion
static QString librawVersion()
Return LibRaw version string.
Definition: kdcraw.cpp:525
QString::toUpper
QString toUpper() const
KDcrawIface::KDcraw::version
static QString version()
Return a string version of libkdcraw release.
Definition: kdcraw.cpp:73
KDcrawIface::KDcraw::Private
Definition: kdcraw_p.h:55
QByteArray
QImage::save
bool save(const QString &fileName, const char *format, int quality) const
KDcrawIface::KDcraw::KDcraw
KDcraw()
Standard constructor.
Definition: kdcraw.cpp:61
KDcrawIface::KDcraw::Private::loadHalfPreview
static bool loadHalfPreview(QImage &, LibRaw &)
KDcrawIface::KDcraw::Private::loadEmbeddedPreview
static bool loadEmbeddedPreview(QByteArray &, LibRaw &)
KDcrawIface::callbackForLibRaw
int callbackForLibRaw(void *data, enum LibRaw_progress p, int iteration, int expected)
KDcrawIface::DcrawInfoContainer
Definition: dcrawinfocontainer.h:43
KDcrawIface::KDcraw::Private::fillIndentifyInfo
static void fillIndentifyInfo(LibRaw *const raw, DcrawInfoContainer &identify)
QBuffer
KDcrawIface::KDcraw::m_cancel
bool m_cancel
Used internally to cancel RAW decoding operation.
Definition: kdcraw.h:232
KDcrawIface::RawDecodingSettings::sixteenBitsImage
bool sixteenBitsImage
Turn on RAW file decoding in 16 bits per color per pixel instead 8 bits.
Definition: rawdecodingsettings.h:207
KDcrawIface::KDcraw::m_rawDecodingSettings
RawDecodingSettings m_rawDecodingSettings
The settings container used to perform RAW pictures decoding.
Definition: kdcraw.h:237
QString::remove
QString & remove(int position, int n)
KDcrawIface::KDcraw::Private::setProgress
void setProgress(double value)
KDcrawIface::KDcraw::librawUseGomp
static int librawUseGomp()
Return true or false if LibRaw use parallel demosaicing or not (libgomp support). ...
Definition: kdcraw.cpp:530
KDcrawIface::KDcraw::~KDcraw
virtual ~KDcraw()
Standard destructor.
Definition: kdcraw.cpp:67
KDcrawIface::KDcraw::librawUseGPL3DemosaicPack
static int librawUseGPL3DemosaicPack()
Return true or false if LibRaw use Demosaic Pack GPL3 or not.
Definition: kdcraw.cpp:569
KDcrawIface::KDcraw::rawFilesVersion
static int rawFilesVersion()
Returns a version number for the list of supported RAW file types.
Definition: kdcraw.cpp:509
QByteArray::resize
void resize(int size)
QList::append
void append(const T &value)
KDcrawIface::KDcraw::rawFiles
static const char * rawFiles()
Return the string of all RAW file type mime supported.
Definition: kdcraw.cpp:498
rawfiles.h
===========================================================This file is a part of digiKam project htt...
QString::isEmpty
bool isEmpty() const
KDcrawIface::KDcraw::loadFullImage
static bool loadFullImage(QImage &image, const QString &path, const RawDecodingSettings &settings=RawDecodingSettings())
Get the full decoded RAW picture.
Definition: kdcraw.cpp:258
loader
static const KCatalogLoader loader("libkdcraw")
QBuffer::open
virtual bool open(QFlags< QIODevice::OpenModeFlag > flags)
raw_file_extensions_version
static const int raw_file_extensions_version
Definition: rawfiles.h:97
QString
raw_file_extentions
static const char raw_file_extentions[]
Definition: rawfiles.h:36
QStringList
KDcrawIface::DcrawInfoContainer::isDecodable
bool isDecodable
True is RAW file is decodable by dcraw.
Definition: dcrawinfocontainer.h:75
QBuffer::data
const QByteArray & data() const
QFileInfo
QFileInfo::exists
bool exists() const
KDcrawIface::KDcraw::setWaitingDataProgress
virtual void setWaitingDataProgress(double value)
Re-implement this method to control the pseudo progress value during RAW decoding (when dcraw run wit...
Definition: kdcraw.cpp:494
QString::contains
bool contains(QChar ch, Qt::CaseSensitivity cs) const
kdcraw_p.h
===========================================================This file is a part of digiKam project htt...
KDcrawIface::KDcraw::checkToCancelWaitingData
virtual bool checkToCancelWaitingData()
Re-implement this method to control the cancelisation of loop witch wait data from RAW decoding proce...
Definition: kdcraw.cpp:489
KDcrawIface::KDcraw::rawFilesList
static QStringList rawFilesList()
Return the list of all RAW file type mime supported, as a QStringList, without wildcard and suffix do...
Definition: kdcraw.cpp:503
QImage
KDcrawIface::KDcraw::extractRAWData
bool extractRAWData(const QString &filePath, QByteArray &rawData, DcrawInfoContainer &identify, unsigned int shotSelect=0)
Extract Raw image data undemosaiced and without post processing from 'filePath' picture file...
Definition: kdcraw.cpp:350
KDcrawIface::KDcraw::rawFileIdentify
static bool rawFileIdentify(DcrawInfoContainer &identify, const QString &path)
Get the camera settings witch have taken RAW file.
Definition: kdcraw.cpp:313
QFileInfo::suffix
QString suffix() const
KDcrawIface::KDcraw::Private::loadFromLibraw
bool loadFromLibraw(const QString &filePath, QByteArray &imageData, int &width, int &height, int &rgbmax)
KDcrawIface::KDcraw
Definition: kdcraw.h:55
KDcrawIface::KDcraw::librawUseGPL2DemosaicPack
static int librawUseGPL2DemosaicPack()
Return true or false if LibRaw use Demosaic Pack GPL2 or not.
Definition: kdcraw.cpp:556
KDcrawIface::KDcraw::decodeHalfRAWImage
bool decodeHalfRAWImage(const QString &filePath, const RawDecodingSettings &rawDecodingSettings, QByteArray &imageData, int &width, int &height, int &rgbmax)
Extract a small size of decode RAW data from 'filePath' picture file using 'rawDecodingSettings' sett...
Definition: kdcraw.cpp:474
QByteArray::data
char * data()
QImage::bits
uchar * bits()
QString::fromLatin1
QString fromLatin1(const char *str, int size)
KDcrawIface::KDcraw::cancel
void cancel()
To cancel 'decodeHalfRAWImage' and 'decodeRAWImage' methods running in a separate thread...
Definition: kdcraw.cpp:78
KDcrawIface::KDcraw::loadRawPreview
static bool loadRawPreview(QImage &image, const QString &path)
Get the preview of RAW picture as a QImage.
Definition: kdcraw.cpp:83
KDcrawIface::RawDecodingSettings
Definition: rawdecodingsettings.h:50
KDcrawIface::KDcraw::librawUseRawSpeed
static int librawUseRawSpeed()
Return true or false if LibRaw use RawSpeed codec or not.
Definition: kdcraw.cpp:543
QByteArray::size
int size() const
KDcrawIface::KDcraw::loadHalfPreview
static bool loadHalfPreview(QImage &image, const QString &path)
Get the half decoded RAW picture.
Definition: kdcraw.cpp:155
KDcrawIface::KDcraw::supportedCamera
static QStringList supportedCamera()
Provide a list of supported RAW Camera name.
Definition: kdcraw.cpp:514
KDcrawIface::KDcraw::decodeRAWImage
bool decodeRAWImage(const QString &filePath, const RawDecodingSettings &rawDecodingSettings, QByteArray &imageData, int &width, int &height, int &rgbmax)
Extract a full size of RAW data from 'filePath' picture file using 'rawDecodingSettings' settings...
Definition: kdcraw.cpp:482
KDcrawIface::KDcraw::loadEmbeddedPreview
static bool loadEmbeddedPreview(QByteArray &imgData, const QString &path)
Get the embedded JPEG preview image from RAW picture as a QByteArray which will include Exif Data...
Definition: kdcraw.cpp:114
QFile::encodeName
QByteArray encodeName(const QString &fileName)
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:19:36 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

libs/libkdcraw/libkdcraw

Skip menu "libs/libkdcraw/libkdcraw"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members

kdegraphics API Reference

Skip menu "kdegraphics API Reference"
  •     libkdcraw
  •     libkexiv2
  •     libkipi
  •     libksane
  • okular

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal