Debian Codegraph @

core/libs/album/engine/albumthumbnailloader.cpp

raw
1 /* ============================================================
2 *
3 * This file is a part of digiKam project
4 * https://www.digikam.org
5 *
6 * Date : 2006-04-14
7 * Description : Load and cache tag thumbnails
8 *
9 * SPDX-FileCopyrightText: 2006-2010 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
10 * SPDX-FileCopyrightText: 2015 by Mohamed_Anwer <m_dot_anwer at gmx dot com>
11 *
12 * SPDX-License-Identifier: GPL-2.0-or-later
13 *
14 * ============================================================ */
15
16 #include "albumthumbnailloader.h"
17
18 // C++ includes
19
20 #include <cmath>
21
22 // Qt includes
23
24 #include <QList>
25 #include <QMap>
26 #include <QCache>
27 #include <QPair>
28
29 // Local includes
30
31 #include "digikam_debug.h"
32 #include "album.h"
33 #include "albummanager.h"
34 #include "thememanager.h"
35 #include "applicationsettings.h"
36 #include "collectionlocation.h"
37 #include "collectionmanager.h"
38 #include "coredb.h"
39 #include "coredbaccess.h"
40 #include "iteminfo.h"
41 #include "faceutils.h"
42 #include "metaenginesettings.h"
43 #include "thumbnailloadthread.h"
44 #include "thumbnailsize.h"
45 #include "thumbnailcreator.h"
46 #include "dio.h"
47
48 namespace Digikam
49 {
50
51 typedef QMap<QPair<qlonglong, QString>, QList<int> > IdAlbumMap;
52 typedef QMap<int, QPixmap> AlbumThumbnailMap;
53
54 class Q_DECL_HIDDEN AlbumThumbnailLoaderCreator
55 {
56 public:
57
58 AlbumThumbnailLoader object;
59 };
60
61 Q_GLOBAL_STATIC(AlbumThumbnailLoaderCreator, creator)
62
63 // ---------------------------------------------------------------------------------------------
64
65 class Q_DECL_HIDDEN AlbumThumbnailLoader::Private
66 {
67 public:
68
69 Private() = default;
70
71 public:
72
73 int iconSize = ApplicationSettings::instance()->getTreeViewIconSize();
74 int faceSize = ApplicationSettings::instance()->getTreeViewFaceSize();
75 int minBlendSize = 20;
76
77 ThumbnailLoadThread* iconTagThumbThread = nullptr;
78 ThumbnailLoadThread* iconFaceThumbThread = nullptr;
79 ThumbnailLoadThread* iconAlbumThumbThread = nullptr;
80
81 QIcon fallBackIcon = QIcon::fromTheme(QLatin1String("dialog-cancel"));
82
83 IdAlbumMap idAlbumMap;
84
85 AlbumThumbnailMap thumbnailMap;
86
87 QCache<QPair<QString, int>, QPixmap> iconCache;
88 };
89
90 bool operator<(const ThumbnailIdentifier& a, const ThumbnailIdentifier& b)
91 {
92 if (a.id || b.id)
93 {
94 return (a.id < b.id);
95 }
96 else
97 {
98 return (a.filePath < b.filePath);
99 }
100 }
101
102 AlbumThumbnailLoader* AlbumThumbnailLoader::instance()
103 {
104 return &creator->object;
105 }
106
107 AlbumThumbnailLoader::~AlbumThumbnailLoader()
108 {
109 delete d->iconAlbumThumbThread;
110 delete d->iconFaceThumbThread;
111 delete d->iconTagThumbThread;
112
113 delete d;
114 }
115
116 AlbumThumbnailLoader::AlbumThumbnailLoader()
117 : QObject(),
118 d (new Private)
119 {
120 connect(this, SIGNAL(signalDispatchThumbnailInternal(int,QPixmap)),
121 this, SLOT(slotDispatchThumbnailInternal(int,QPixmap)));
122
123 connect(AlbumManager::instance(), SIGNAL(signalAlbumIconChanged(Album*)),
124 this, SLOT(slotIconChanged(Album*)));
125
126 connect(AlbumManager::instance(), SIGNAL(signalAlbumDeleted(Album*)),
127 this, SLOT(slotIconChanged(Album*)));
128
129 connect(ThemeManager::instance(), &ThemeManager::signalThemeChanged,
130 this, [this]()
131 {
132 d->iconCache.clear();
133 }
134 );
135 }
136
137 void AlbumThumbnailLoader::cleanUp()
138 {
139 if (d->iconAlbumThumbThread)
140 {
141 d->iconAlbumThumbThread->stopAllTasks();
142 d->iconAlbumThumbThread->wait();
143 }
144
145 if (d->iconFaceThumbThread)
146 {
147 d->iconFaceThumbThread->stopAllTasks();
148 d->iconFaceThumbThread->wait();
149 }
150
151 if (d->iconTagThumbThread)
152 {
153 d->iconTagThumbThread->stopAllTasks();
154 d->iconTagThumbThread->wait();
155 }
156 }
157
158 QPixmap AlbumThumbnailLoader::getStandardTagIcon(RelativeSize relativeSize)
159 {
160 return loadIcon(QLatin1String("tag"), computeIconSize(relativeSize));
161 }
162
163 QPixmap AlbumThumbnailLoader::getStandardTagRootIcon(RelativeSize relativeSize)
164 {
165 return loadIcon(QLatin1String("document-open"), computeIconSize(relativeSize));
166 }
167
168 QPixmap AlbumThumbnailLoader::getStandardTagIcon(TAlbum* const album, RelativeSize relativeSize)
169 {
170 if (album->isRoot())
171 {
172 return getStandardTagRootIcon(relativeSize);
173 }
174 else
175 {
176 return getStandardTagIcon(relativeSize);
177 }
178 }
179
180 QPixmap AlbumThumbnailLoader::getStandardAlbumIcon(PAlbum* const album, RelativeSize relativeSize)
181 {
182 if (album->isRoot() || album->isAlbumRoot())
183 {
184 return getStandardAlbumRootIcon(relativeSize);
185 }
186 else if (album->isTrashAlbum())
187 {
188 const PAlbum* const palbum = static_cast<PAlbum*>(album->parent());
189
190 if (palbum)
191 {
192 if (DIO::getTrashCounter(palbum->folderPath()) > 0)
193 {
194 return getStandardFullTrashIcon(relativeSize);
195 }
196 }
197
198 return getStandardEmptyTrashIcon(relativeSize);
199 }
200
201 return getStandardAlbumIcon(relativeSize);
202 }
203
204 QPixmap AlbumThumbnailLoader::getStandardFaceIcon(TAlbum* const /*album*/, RelativeSize relativeSize)
205 {
206 return loadIcon(QLatin1String("smiley"), computeFaceSize(relativeSize));
207 }
208
209 QPixmap AlbumThumbnailLoader::getNewTagIcon(RelativeSize relativeSize)
210 {
211 return loadIcon(QLatin1String("tag-new"), computeIconSize(relativeSize));
212 }
213
214 QPixmap AlbumThumbnailLoader::getStandardEmptyTrashIcon(RelativeSize relativeSize)
215 {
216 return loadIcon(QLatin1String("user-trash"), computeIconSize(relativeSize));
217 }
218
219 QPixmap AlbumThumbnailLoader::getStandardFullTrashIcon(RelativeSize relativeSize)
220 {
221 return loadIcon(QLatin1String("user-trash-full"), computeIconSize(relativeSize));
222 }
223
224 QPixmap AlbumThumbnailLoader::getStandardAlbumRootIcon(RelativeSize relativeSize)
225 {
226 return loadIcon(QLatin1String("folder-pictures"), computeIconSize(relativeSize));
227 }
228
229 QPixmap AlbumThumbnailLoader::getStandardOfflineIcon(RelativeSize relativeSize)
230 {
231 return loadIcon(QLatin1String("data-error"), computeIconSize(relativeSize));
232 }
233
234 QPixmap AlbumThumbnailLoader::getStandardAlbumIcon(RelativeSize relativeSize)
235 {
236 return loadIcon(QLatin1String("folder"), computeIconSize(relativeSize));
237 }
238
239 int AlbumThumbnailLoader::computeIconSize(RelativeSize relativeSize) const
240 {
241 if (relativeSize == SmallerSize)
242 {
243 // when size was 32 smaller was 20. Scale.
244
245 return lround(20.0 / 32.0 * (double)d->iconSize);
246 }
247
248 return d->iconSize;
249 }
250
251 int AlbumThumbnailLoader::computeFaceSize(RelativeSize relativeSize) const
252 {
253 if (relativeSize == SmallerSize)
254 {
255 // when size was 32 smaller was 20. Scale.
256
257 return lround(20.0 / 32.0 * (double)d->faceSize);
258 }
259
260 return d->faceSize;
261 }
262
263 QPixmap AlbumThumbnailLoader::loadIcon(const QString& name, int size) const
264 {
265 const QPixmap* cachePix = d->iconCache[qMakePair(name, size)];
266
267 if (!cachePix)
268 {
269 QPixmap pix;
270
271 // We check for a slash to see if it's a path to a file.
272 // This is significantly faster than check with QFileInfo.
273
274 if (name.contains(QLatin1Char('/')))
275 {
276 if (pix.load(name))
277 {
278 pix = pix.scaled(size,
279 size,
280 Qt::KeepAspectRatio,
281 Qt::SmoothTransformation);
282 }
283 else
284 {
285 pix = d->fallBackIcon.pixmap(size);
286 }
287 }
288 else
289 {
290 pix = QIcon::fromTheme(name, d->fallBackIcon).pixmap(size);
291 }
292
293 d->iconCache.insert(qMakePair(name, size), new QPixmap(pix));
294
295 return pix;
296 }
297
298 return (*cachePix); // ownership of the pointer is kept by the icon cache.
299 }
300
301 bool AlbumThumbnailLoader::getTagThumbnail(TAlbum* const album, QPixmap& icon)
302 {
303 if (album->iconId() && (d->iconSize > d->minBlendSize))
304 {
305 addUrl(album, album->iconId());
306 icon = QPixmap();
307
308 return true;
309 }
310 else if (!album->icon().isEmpty())
311 {
312 icon = loadIcon(album->icon(), d->iconSize);
313
314 return false;
315 }
316
317 icon = QPixmap();
318
319 return false;
320 }
321
322 QPixmap AlbumThumbnailLoader::getTagThumbnailDirectly(TAlbum* const album)
323 {
324 if (album->iconId() && (d->iconSize > d->minBlendSize))
325 {
326 // icon cached?
327
328 AlbumThumbnailMap::const_iterator it = d->thumbnailMap.constFind(album->globalID());
329
330 if (it != d->thumbnailMap.constEnd())
331 {
332 return *it;
333 }
334
335 addUrl(album, album->iconId());
336 }
337 else if (!album->icon().isEmpty())
338 {
339 QPixmap pixmap = loadIcon(album->icon(), d->iconSize);
340
341 return pixmap;
342 }
343
344 return getStandardTagIcon(album);
345 }
346
347 QPixmap AlbumThumbnailLoader::getFaceThumbnailDirectly(TAlbum* const album)
348 {
349 if (album->iconId() && (d->faceSize > d->minBlendSize))
350 {
351 // icon cached?
352
353 AlbumThumbnailMap::const_iterator it = d->thumbnailMap.constFind(album->globalID());
354
355 if (it != d->thumbnailMap.constEnd())
356 {
357 return *it;
358 }
359
360 addUrl(album, album->iconId());
361 }
362 else if (!album->icon().isEmpty())
363 {
364 QPixmap pixmap = loadIcon(album->icon(), d->faceSize);
365
366 return pixmap;
367 }
368 else if (!album->iconId() && !FaceTags::isSystemPersonTagId(album->id()))
369 {
370 qlonglong firstItemId = CoreDbAccess().db()->getFirstItemWithFaceTag(album->id());
371
372 if (firstItemId > 0)
373 {
374 QString err;
375
376 if (!AlbumManager::instance()->updateTAlbumIcon(album, QString(),
377 firstItemId, err))
378 {
379 qCDebug(DIGIKAM_GENERAL_LOG) << err;
380 }
381 else
382 {
383 addUrl(album, firstItemId);
384 }
385 }
386 }
387
388 return getStandardFaceIcon(album);
389 }
390
391 bool AlbumThumbnailLoader::getAlbumThumbnail(PAlbum* const album)
392 {
393 if (album->iconId() && (d->iconSize > d->minBlendSize))
394 {
395 addUrl(album, album->iconId());
396 }
397 else
398 {
399 return false;
400 }
401
402 return true;
403 }
404
405 QPixmap AlbumThumbnailLoader::getAlbumThumbnailDirectly(PAlbum* const album)
406 {
407 if (album->isAlbumRoot())
408 {
409 CollectionLocation location = CollectionManager::instance()->locationForAlbumRootId(album->albumRootId());
410
411 if (location.isNull() || !location.isAvailable())
412 {
413 return getStandardOfflineIcon();
414 }
415 }
416
417 if (album->iconId() && !album->isTrashAlbum() && (d->iconSize > d->minBlendSize))
418 {
419 // icon cached?
420
421 AlbumThumbnailMap::const_iterator it = d->thumbnailMap.constFind(album->globalID());
422
423 if (it != d->thumbnailMap.constEnd())
424 {
425 return *it;
426 }
427
428 // schedule for loading
429
430 addUrl(album, album->iconId());
431 }
432
433 return getStandardAlbumIcon(album);
434 }
435
436 void AlbumThumbnailLoader::addUrl(Album* const album, qlonglong id)
437 {
438 // First check cached thumbnails.
439 // We use a private cache which is actually a map to be sure to cache _all_ album thumbnails.
440 // At startup, this is not relevant, as the views will add their requests in a row.
441 // This is to speed up context menu and IE imagedescedit
442
443 AlbumThumbnailMap::const_iterator ttit = d->thumbnailMap.constFind(album->globalID());
444
445 if (ttit != d->thumbnailMap.constEnd())
446 {
447 // It is not necessary to return cached icon asynchronously - they could be
448 // returned by getTagThumbnail already - but this would make the API
449 // less elegant, it feels much better this way.
450
451 Q_EMIT signalDispatchThumbnailInternal(album->globalID(), *ttit);
452
453 return;
454 }
455
456 // Finding face rect to identify correct tag
457
458 QRect faceRect = QRect();
459
460 if ((album->type() == Album::TAG) && static_cast<TAlbum*>(album)->hasProperty(TagPropertyName::person()))
461 {
462 QList<FaceTagsIface> faces = FaceTagsEditor().databaseFaces(id);
463
464 for (const FaceTagsIface& face : std::as_const(faces))
465 {
466 if (face.tagId() == album->id())
467 {
468 faceRect = FaceUtils::faceRectToDisplayRect(face.region().toRect());
469 break;
470 }
471 }
472 }
473
474 // Simple way to put QRect into QMap
475
476 QString faceRectStr = QString(QLatin1String("%1%2%3%4"))
477 .arg(faceRect.x()).arg(faceRect.y()).arg(faceRect.right()).arg(faceRect.bottom());
478
479 // Check if the URL has already been added
480
481 IdAlbumMap::iterator it = d->idAlbumMap.find(QPair<qlonglong, QString>(id, faceRectStr));
482
483 if (it == d->idAlbumMap.end())
484 {
485 // use two threads so that tag and album thumbnails are loaded
486 // in parallel and not first album, then tag thumbnails
487
488 if (album->type() == Album::TAG)
489 {
490 if (!d->iconTagThumbThread)
491 {
492 d->iconTagThumbThread = new ThumbnailLoadThread();
493 d->iconTagThumbThread->setThumbnailSize(d->iconSize);
494 d->iconTagThumbThread->setSendSurrogatePixmap(false);
495
496 connect(d->iconTagThumbThread, SIGNAL(signalThumbnailLoaded(LoadingDescription,QPixmap)),
497 this, SLOT(slotGotThumbnailFromIcon(LoadingDescription,QPixmap)),
498 Qt::QueuedConnection);
499 }
500
501 if (!d->iconFaceThumbThread)
502 {
503 d->iconFaceThumbThread = new ThumbnailLoadThread();
504 d->iconFaceThumbThread->setThumbnailSize(d->faceSize);
505 d->iconFaceThumbThread->setSendSurrogatePixmap(false);
506
507 connect(d->iconFaceThumbThread, SIGNAL(signalThumbnailLoaded(LoadingDescription,QPixmap)),
508 this, SLOT(slotGotThumbnailFromIcon(LoadingDescription,QPixmap)),
509 Qt::QueuedConnection);
510 }
511
512 if (static_cast<TAlbum*>(album)->hasProperty(TagPropertyName::person()))
513 {
514 d->iconFaceThumbThread->find(ItemInfo::thumbnailIdentifier(id), faceRect);
515 }
516 else
517 {
518 d->iconTagThumbThread->find(ItemInfo::thumbnailIdentifier(id));
519 }
520 }
521 else
522 {
523 if (!d->iconAlbumThumbThread)
524 {
525 d->iconAlbumThumbThread = new ThumbnailLoadThread();
526 d->iconAlbumThumbThread->setThumbnailSize(d->iconSize);
527 d->iconAlbumThumbThread->setSendSurrogatePixmap(false);
528
529 connect(d->iconAlbumThumbThread, SIGNAL(signalThumbnailLoaded(LoadingDescription,QPixmap)),
530 this, SLOT(slotGotThumbnailFromIcon(LoadingDescription,QPixmap)),
531 Qt::QueuedConnection);
532 }
533
534 d->iconAlbumThumbThread->find(ItemInfo::thumbnailIdentifier(id));
535 }
536
537 // insert new entry to map, add album globalID
538
539 QList<int>& list = d->idAlbumMap[QPair<qlonglong, QString>(id, faceRectStr)];
540 list.removeAll(album->globalID());
541 list.append(album->globalID());
542 }
543 else
544 {
545 // only add album global ID to list which is already inserted in map
546
547 (*it).removeAll(album->globalID());
548 (*it).append(album->globalID());
549 }
550 }
551
552 void AlbumThumbnailLoader::setThumbnailSize(int size, int face)
553 {
554 if ((d->iconSize == size) && (d->faceSize == face))
555 {
556 return;
557 }
558
559 d->iconSize = size;
560 d->faceSize = face;
561
562 // clear task list
563
564 d->idAlbumMap.clear();
565
566 // clear cached thumbnails
567
568 d->thumbnailMap.clear();
569
570 if (d->iconAlbumThumbThread)
571 {
572 d->iconAlbumThumbThread->stopLoading();
573 d->iconAlbumThumbThread->setThumbnailSize(size);
574 }
575
576 if (d->iconFaceThumbThread)
577 {
578 d->iconFaceThumbThread->stopLoading();
579 d->iconFaceThumbThread->setThumbnailSize(face);
580 }
581
582 if (d->iconTagThumbThread)
583 {
584 d->iconTagThumbThread->stopLoading();
585 d->iconTagThumbThread->setThumbnailSize(size);
586 }
587
588 Q_EMIT signalReloadThumbnails();
589 }
590
591 int AlbumThumbnailLoader::thumbnailSize() const
592 {
593 return d->iconSize;
594 }
595
596 void AlbumThumbnailLoader::slotGotThumbnailFromIcon(const LoadingDescription& loadingDescription, const QPixmap& thumbnail)
597 {
598 // We need to find all albums for which the given url has been requested,
599 // and Q_EMIT a signal for each album.
600
601 QRect faceRect = QRect();
602
603 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
604
605 if (loadingDescription.previewParameters.extraParameter.typeId() == QMetaType::QRect)
606
607 #else
608
609 if (loadingDescription.previewParameters.extraParameter.type() == QVariant::Rect)
610
611 #endif
612
613 {
614 faceRect = loadingDescription.previewParameters.extraParameter.toRect();
615 }
616
617 // Simple way to put QRect into QMap
618
619 QString faceRectStr = QString(QLatin1String("%1%2%3%4"))
620 .arg(faceRect.x()).arg(faceRect.y()).arg(faceRect.right()).arg(faceRect.bottom());
621
622 ThumbnailIdentifier id = loadingDescription.thumbnailIdentifier();
623 IdAlbumMap::iterator it = d->idAlbumMap.find(QPair<qlonglong, QString>(id.id, faceRectStr));
624
625 if (it != d->idAlbumMap.end())
626 {
627 AlbumManager* const manager = AlbumManager::instance();
628
629 if (thumbnail.isNull())
630 {
631 // Loading failed
632
633 for (QList<int>::const_iterator vit = (*it).constBegin() ; vit != (*it).constEnd() ; ++vit)
634 {
635 Album* const album = manager->findAlbum(*vit);
636
637 if (album)
638 {
639 Q_EMIT signalFailed(album);
640 }
641 }
642 }
643 else
644 {
645 // Loading succeeded
646
647 for (QList<int>::const_iterator vit = (*it).constBegin() ; vit != (*it).constEnd() ; ++vit)
648 {
649 // look up with global id
650
651 Album* const album = manager->findAlbum(*vit);
652
653 if (album)
654 {
655 d->thumbnailMap.insert(album->globalID(), thumbnail);
656
657 Q_EMIT signalThumbnail(album, thumbnail);
658 }
659 }
660 }
661
662 d->idAlbumMap.erase(it);
663 }
664 }
665
666 void AlbumThumbnailLoader::slotDispatchThumbnailInternal(int albumID, const QPixmap& thumbnail)
667 {
668 // for cached thumbnails
669
670 AlbumManager* const manager = AlbumManager::instance();
671 Album* const album = manager->findAlbum(albumID);
672
673 if (album)
674 {
675 if (thumbnail.isNull())
676 {
677 Q_EMIT signalFailed(album);
678 }
679 else
680 {
681 Q_EMIT signalThumbnail(album, thumbnail);
682 }
683 }
684 }
685
686 void AlbumThumbnailLoader::slotIconChanged(Album* album)
687 {
688 if (!album || ((album->type() != Album::TAG) && (album->type() != Album::PHYSICAL)))
689 {
690 return;
691 }
692
693 d->thumbnailMap.remove(album->globalID());
694 }
695
696 /*
697 * This code is maximally inefficient
698 QImage AlbumThumbnailLoader::getAlbumPreviewDirectly(PAlbum* const album, int size)
699 {
700 if (album->iconId())
701 {
702 ThumbnailLoadThread* const thread = new ThumbnailLoadThread;
703 thread->setPixmapRequested(false);
704 thread->setThumbnailSize(size);
705 ThumbnailImageCatcher* const catcher = new ThumbnailImageCatcher(thread);
706 catcher->setActive(true);
707 catcher->thread()->find(ThumbnailIdentifier(album->iconId());
708 catcher->enqueue();
709 QList<QImage> images = catcher->waitForThumbnails();
710 catcher->setActive(false);
711 delete thread;
712 delete catcher;
713
714 if (!images.isEmpty())
715 {
716 return images[0];
717 }
718 }
719
720 return loadIcon("folder", size).toImage();
721 }
722 */
723
724 } // namespace Digikam
725
726 #include "moc_albumthumbnailloader.cpp"