sd/source/ui/slidesorter/cache/SlsBitmapCache.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <officecfg/Office/Impress.hxx>
  21
  22 #include <memory>
  23 #include <unordered_map>
  24 #include "SlsBitmapCache.hxx"
  25 #include "SlsCacheCompactor.hxx"
  26 #include "SlsBitmapCompressor.hxx"
  27
  28 #include <sal/log.hxx>
  29
  30 // Define the default value for the maximal cache size that is used for
  31 // previews that are currently not visible.  The visible previews are all
  32 // held in memory at all times.  This default is used only when the
  33 // configuration does not have a value.
  34 const sal_Int32 MAXIMAL_CACHE_SIZE = 4*1024L*1024L;
  35
  36 using namespace ::com::sun::star::uno;
  37
  38 namespace sd::slidesorter::cache {
  39
  40 class BitmapCache::CacheEntry
  41 {
  42 public:
  43     CacheEntry(const BitmapEx& rBitmap, sal_Int32 nLastAccessTime, bool bIsPrecious);
  44     CacheEntry(sal_Int32 nLastAccessTime, bool bIsPrecious);
  45     inline void Recycle (const CacheEntry& rEntry);
  46     inline sal_Int32 GetMemorySize() const;
  47     void Compress (const std::shared_ptr<BitmapCompressor>& rpCompressor);
  48     inline void Decompress();
  49
  50     bool IsUpToDate() const { return mbIsUpToDate; }
  51     void SetUpToDate (bool bIsUpToDate) { mbIsUpToDate = bIsUpToDate; }
  52     sal_Int32 GetAccessTime() const { return mnLastAccessTime; }
  53     void SetAccessTime (sal_Int32 nAccessTime) { mnLastAccessTime = nAccessTime; }
  54
  55     const BitmapEx& GetPreview() const { return maPreview; }
  56     inline void SetPreview (const BitmapEx& rPreview);
  57     bool HasPreview() const;
  58
  59     const BitmapEx& GetMarkedPreview() const { return maMarkedPreview; }
  60     inline void SetMarkedPreview (const BitmapEx& rMarkePreview);
  61
  62     bool HasReplacement() const { return (mpReplacement != nullptr); }
  63     inline bool HasLosslessReplacement() const;
  64     void Invalidate() { mpReplacement.reset(); mpCompressor.reset(); mbIsUpToDate = false; }
  65     bool IsPrecious() const { return mbIsPrecious; }
  66     void SetPrecious (bool bIsPrecious) { mbIsPrecious = bIsPrecious; }
  67
  68 private:
  69     BitmapEx maPreview;
  70     BitmapEx maMarkedPreview;
  71     std::shared_ptr<BitmapReplacement> mpReplacement;
  72     std::shared_ptr<BitmapCompressor> mpCompressor;
  73     bool mbIsUpToDate;
  74     sal_Int32 mnLastAccessTime;
  75     // When this flag is set then the bitmap is not modified by a cache
  76     // compactor.
  77     bool mbIsPrecious;
  78 };
  79
  80 namespace {
  81
  82 class CacheHash {
  83 public:
  84     size_t operator()(const BitmapCache::CacheKey& p) const
  85     { return reinterpret_cast<size_t>(p); }
  86 };
  87
  88 }
  89
  90 class BitmapCache::CacheBitmapContainer
  91     : public std::unordered_map<CacheKey, CacheEntry, CacheHash>
  92 {
  93 public:
  94     CacheBitmapContainer() {}
  95 };
  96
  97 namespace {
  98
  99 typedef ::std::vector<
 100     ::std::pair< ::sd::slidesorter::cache::BitmapCache::CacheKey,
 101       ::sd::slidesorter::cache::BitmapCache::CacheEntry>
 102     > SortableBitmapContainer;
 103
 104     /** Compare elements of the bitmap cache according to their last access
 105         time.
 106     */
 107     class AccessTimeComparator
 108     {
 109     public:
 110         bool operator () (
 111             const SortableBitmapContainer::value_type& e1,
 112             const SortableBitmapContainer::value_type& e2)
 113         {
 114             return e1.second.GetAccessTime() < e2.second.GetAccessTime();
 115         }
 116     };
 117
 118 } // end of anonymous namespace
 119
 120 //=====  BitmapCache  =========================================================
 121
 122 BitmapCache::BitmapCache ()
 123     : mpBitmapContainer(new CacheBitmapContainer()),
 124       mnNormalCacheSize(0),
 125       mnPreciousCacheSize(0),
 126       mnCurrentAccessTime(0),
 127       mnMaximalNormalCacheSize(MAXIMAL_CACHE_SIZE),
 128       mbIsFull(false)
 129 {
 130     mnMaximalNormalCacheSize = officecfg::Office::Impress::MultiPaneGUI::SlideSorterBar::PreviewCache::CacheSize::get();
 131
 132     mpCacheCompactor = CacheCompactor::Create(*this,mnMaximalNormalCacheSize);
 133 }
 134
 135 BitmapCache::~BitmapCache()
 136 {
 137     Clear();
 138 }
 139
 140 void BitmapCache::Clear()
 141 {
 142     std::unique_lock aGuard (maMutex);
 143
 144     mpBitmapContainer->clear();
 145     mnNormalCacheSize = 0;
 146     mnPreciousCacheSize = 0;
 147     mnCurrentAccessTime = 0;
 148 }
 149
 150 bool BitmapCache::HasBitmap (const CacheKey& rKey)
 151 {
 152     std::unique_lock aGuard (maMutex);
 153
 154     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 155     return (iEntry != mpBitmapContainer->end()
 156         && (iEntry->second.HasPreview() || iEntry->second.HasReplacement()));
 157 }
 158
 159 bool BitmapCache::BitmapIsUpToDate (const CacheKey& rKey)
 160 {
 161     std::unique_lock aGuard (maMutex);
 162
 163     bool bIsUpToDate = false;
 164     CacheBitmapContainer::iterator aIterator (mpBitmapContainer->find(rKey));
 165     if (aIterator != mpBitmapContainer->end())
 166         bIsUpToDate = aIterator->second.IsUpToDate();
 167
 168     return bIsUpToDate;
 169 }
 170
 171 BitmapEx BitmapCache::GetBitmap (const CacheKey& rKey)
 172 {
 173     std::unique_lock aGuard (maMutex);
 174
 175     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 176     if (iEntry == mpBitmapContainer->end())
 177     {
 178         // Create an empty bitmap for the given key that acts as placeholder
 179         // until we are given the real one.  Mark it as not being up to date.
 180         SetBitmap(aGuard, rKey, BitmapEx(), false);
 181         iEntry = mpBitmapContainer->find(rKey);
 182         iEntry->second.SetUpToDate(false);
 183     }
 184     else
 185     {
 186         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 187
 188         // Maybe we have to decompress the preview.
 189         if ( ! iEntry->second.HasPreview() && iEntry->second.HasReplacement())
 190         {
 191             UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 192             iEntry->second.Decompress();
 193             UpdateCacheSize(aGuard, iEntry->second, ADD);
 194         }
 195     }
 196     return iEntry->second.GetPreview();
 197 }
 198
 199 BitmapEx BitmapCache::GetMarkedBitmap (const CacheKey& rKey)
 200 {
 201     std::unique_lock aGuard (maMutex);
 202
 203     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 204     if (iEntry != mpBitmapContainer->end())
 205     {
 206         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 207         return iEntry->second.GetMarkedPreview();
 208     }
 209     else
 210         return BitmapEx();
 211 }
 212
 213 void BitmapCache::ReleaseBitmap (const CacheKey& rKey)
 214 {
 215     std::unique_lock aGuard (maMutex);
 216
 217     CacheBitmapContainer::iterator aIterator (mpBitmapContainer->find(rKey));
 218     if (aIterator != mpBitmapContainer->end())
 219     {
 220         UpdateCacheSize(aGuard, aIterator->second, REMOVE);
 221         mpBitmapContainer->erase(aIterator);
 222     }
 223 }
 224
 225 bool BitmapCache::InvalidateBitmap (const CacheKey& rKey)
 226 {
 227     std::unique_lock aGuard (maMutex);
 228
 229     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 230     if (iEntry != mpBitmapContainer->end())
 231     {
 232         iEntry->second.SetUpToDate(false);
 233
 234         // When there is a preview then we release the replacement.  The
 235         // preview itself is kept until a new one is created.
 236         if (iEntry->second.HasPreview())
 237         {
 238             UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 239             iEntry->second.Invalidate();
 240             UpdateCacheSize(aGuard, iEntry->second, ADD);
 241         }
 242         return true;
 243     }
 244     else
 245         return false;
 246 }
 247
 248 void BitmapCache::InvalidateCache()
 249 {
 250     std::unique_lock aGuard (maMutex);
 251
 252     for (auto& rEntry : *mpBitmapContainer)
 253     {
 254         rEntry.second.Invalidate();
 255     }
 256     ReCalculateTotalCacheSize(aGuard);
 257 }
 258
 259 void BitmapCache::SetBitmap (
 260     const CacheKey& rKey,
 261     const BitmapEx& rPreview,
 262     bool bIsPrecious)
 263 {
 264     std::unique_lock aGuard (maMutex);
 265     SetBitmap(aGuard, rKey, rPreview, bIsPrecious);
 266 }
 267
 268 void BitmapCache::SetBitmap (
 269     std::unique_lock<std::mutex>& rGuard,
 270     const CacheKey& rKey,
 271     const BitmapEx& rPreview,
 272     bool bIsPrecious)
 273 {
 274     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 275     if (iEntry != mpBitmapContainer->end())
 276     {
 277         UpdateCacheSize(rGuard, iEntry->second, REMOVE);
 278         iEntry->second.SetPreview(rPreview);
 279         iEntry->second.SetUpToDate(true);
 280         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 281     }
 282     else
 283     {
 284         iEntry = mpBitmapContainer->emplace(
 285             rKey,
 286             CacheEntry(rPreview, mnCurrentAccessTime++, bIsPrecious)
 287             ).first;
 288     }
 289
 290     if (iEntry != mpBitmapContainer->end())
 291         UpdateCacheSize(rGuard, iEntry->second, ADD);
 292 }
 293
 294 void BitmapCache::SetMarkedBitmap (
 295     const CacheKey& rKey,
 296     const BitmapEx& rPreview)
 297 {
 298     std::unique_lock aGuard (maMutex);
 299
 300     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 301     if (iEntry != mpBitmapContainer->end())
 302     {
 303         UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 304         iEntry->second.SetMarkedPreview(rPreview);
 305         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 306         UpdateCacheSize(aGuard, iEntry->second, ADD);
 307     }
 308 }
 309
 310 void BitmapCache::SetPrecious (const CacheKey& rKey, bool bIsPrecious)
 311 {
 312     std::unique_lock aGuard (maMutex);
 313
 314     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 315     if (iEntry != mpBitmapContainer->end())
 316     {
 317         if (iEntry->second.IsPrecious() != bIsPrecious)
 318         {
 319             UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 320             iEntry->second.SetPrecious(bIsPrecious);
 321             UpdateCacheSize(aGuard, iEntry->second, ADD);
 322         }
 323     }
 324     else if (bIsPrecious)
 325     {
 326         iEntry = mpBitmapContainer->emplace(
 327             rKey,
 328             CacheEntry(BitmapEx(), mnCurrentAccessTime++, bIsPrecious)
 329             ).first;
 330         UpdateCacheSize(aGuard, iEntry->second, ADD);
 331     }
 332 }
 333
 334 void BitmapCache::ReCalculateTotalCacheSize()
 335 {
 336     std::unique_lock aGuard (maMutex);
 337     ReCalculateTotalCacheSize(aGuard);
 338 }
 339
 340 void BitmapCache::ReCalculateTotalCacheSize(std::unique_lock<std::mutex>& /*rGuard*/)
 341 {
 342     mnNormalCacheSize = 0;
 343     mnPreciousCacheSize = 0;
 344     for (const auto& rEntry : *mpBitmapContainer)
 345     {
 346         if (rEntry.second.IsPrecious())
 347             mnPreciousCacheSize += rEntry.second.GetMemorySize();
 348         else
 349             mnNormalCacheSize += rEntry.second.GetMemorySize();
 350     }
 351     mbIsFull = (mnNormalCacheSize  >= mnMaximalNormalCacheSize);
 352
 353     SAL_INFO("sd.sls", __func__ << ": cache size is " << mnNormalCacheSize << "/" << mnPreciousCacheSize);
 354 }
 355
 356 void BitmapCache::Recycle (const BitmapCache& rCache)
 357 {
 358     std::unique_lock aGuard (maMutex);
 359
 360     for (const auto& rOtherEntry : *rCache.mpBitmapContainer)
 361     {
 362         CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rOtherEntry.first));
 363         if (iEntry == mpBitmapContainer->end())
 364         {
 365             iEntry = mpBitmapContainer->emplace(
 366                 rOtherEntry.first,
 367                 CacheEntry(mnCurrentAccessTime++, true)
 368                 ).first;
 369             UpdateCacheSize(aGuard, iEntry->second, ADD);
 370         }
 371         if (iEntry != mpBitmapContainer->end())
 372         {
 373             UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 374             iEntry->second.Recycle(rOtherEntry.second);
 375             UpdateCacheSize(aGuard, iEntry->second, ADD);
 376         }
 377     }
 378 }
 379
 380 BitmapCache::CacheIndex BitmapCache::GetCacheIndex() const
 381 {
 382     std::unique_lock aGuard (maMutex);
 383
 384     // Create a copy of the bitmap container.
 385     SortableBitmapContainer aSortedContainer;
 386     aSortedContainer.reserve(mpBitmapContainer->size());
 387
 388     // Copy the relevant entries.
 389     for (const auto& rEntry : *mpBitmapContainer)
 390     {
 391         if ( rEntry.second.IsPrecious())
 392             continue;
 393
 394         if ( ! rEntry.second.HasPreview())
 395             continue;
 396
 397         aSortedContainer.emplace_back(rEntry.first, rEntry.second);
 398     }
 399
 400     // Sort the remaining entries.
 401     ::std::sort(aSortedContainer.begin(), aSortedContainer.end(), AccessTimeComparator());
 402
 403     // Return a list with the keys of the sorted entries.
 404     CacheIndex aIndex;
 405     aIndex.reserve(aSortedContainer.size());
 406     for (const auto& rIndexEntry : aSortedContainer)
 407         aIndex.push_back(rIndexEntry.first);
 408     return aIndex;
 409 }
 410
 411 void BitmapCache::Compress (
 412     const CacheKey& rKey,
 413     const std::shared_ptr<BitmapCompressor>& rpCompressor)
 414 {
 415     std::unique_lock aGuard (maMutex);
 416
 417     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 418     if (iEntry != mpBitmapContainer->end() && iEntry->second.HasPreview())
 419     {
 420         UpdateCacheSize(aGuard, iEntry->second, REMOVE);
 421         iEntry->second.Compress(rpCompressor);
 422         UpdateCacheSize(aGuard, iEntry->second, ADD);
 423     }
 424 }
 425
 426 void BitmapCache::UpdateCacheSize (std::unique_lock<std::mutex>& /*rGuard*/, const CacheEntry& rEntry, CacheOperation eOperation)
 427 {
 428     sal_Int32 nEntrySize (rEntry.GetMemorySize());
 429     sal_Int32& rCacheSize (rEntry.IsPrecious() ? mnPreciousCacheSize : mnNormalCacheSize);
 430     switch (eOperation)
 431     {
 432         case ADD:
 433             rCacheSize += nEntrySize;
 434             if ( ! rEntry.IsPrecious() && mnNormalCacheSize>mnMaximalNormalCacheSize)
 435             {
 436                 mbIsFull = true;
 437                 SAL_INFO("sd.sls", __func__ << ": cache size is " << mnNormalCacheSize << " > " << mnMaximalNormalCacheSize);
 438                 mpCacheCompactor->RequestCompaction();
 439             }
 440             break;
 441
 442         case REMOVE:
 443             rCacheSize -= nEntrySize;
 444             if (mnNormalCacheSize < mnMaximalNormalCacheSize)
 445                 mbIsFull = false;
 446             break;
 447
 448         default:
 449             assert(false);
 450             break;
 451     }
 452 }
 453
 454 //===== CacheEntry ============================================================
 455
 456 BitmapCache::CacheEntry::CacheEntry(
 457     sal_Int32 nLastAccessTime,
 458     bool bIsPrecious)
 459     : mbIsUpToDate(true),
 460       mnLastAccessTime(nLastAccessTime),
 461       mbIsPrecious(bIsPrecious)
 462 {
 463 }
 464
 465 BitmapCache::CacheEntry::CacheEntry(
 466     const BitmapEx& rPreview,
 467     sal_Int32 nLastAccessTime,
 468     bool bIsPrecious)
 469     : maPreview(rPreview),
 470       mbIsUpToDate(true),
 471       mnLastAccessTime(nLastAccessTime),
 472       mbIsPrecious(bIsPrecious)
 473 {
 474 }
 475
 476 inline void BitmapCache::CacheEntry::Recycle (const CacheEntry& rEntry)
 477 {
 478     if ((rEntry.HasPreview() || rEntry.HasLosslessReplacement())
 479         && ! (HasPreview() || HasLosslessReplacement()))
 480     {
 481         maPreview = rEntry.maPreview;
 482         maMarkedPreview = rEntry.maMarkedPreview;
 483         mpReplacement = rEntry.mpReplacement;
 484         mpCompressor = rEntry.mpCompressor;
 485         mnLastAccessTime = rEntry.mnLastAccessTime;
 486         mbIsUpToDate = rEntry.mbIsUpToDate;
 487     }
 488 }
 489
 490 inline sal_Int32 BitmapCache::CacheEntry::GetMemorySize() const
 491 {
 492     sal_Int32 nSize (0);
 493     nSize += maPreview.GetSizeBytes();
 494     nSize += maMarkedPreview.GetSizeBytes();
 495     if (mpReplacement != nullptr)
 496         nSize += mpReplacement->GetMemorySize();
 497     return nSize;
 498 }
 499
 500 void BitmapCache::CacheEntry::Compress (const std::shared_ptr<BitmapCompressor>& rpCompressor)
 501 {
 502     if (  maPreview.IsEmpty())
 503         return;
 504
 505     if (mpReplacement == nullptr)
 506     {
 507         mpReplacement = rpCompressor->Compress(maPreview);
 508
 509 #ifdef DEBUG_SD_SLSBITMAPCACHE
 510         sal_uInt32 nOldSize (maPreview.GetSizeBytes());
 511         sal_uInt32 nNewSize (mpReplacement.get()!=NULL ? mpReplacement->GetMemorySize() : 0);
 512         if (nOldSize == 0)
 513             nOldSize = 1;
 514         sal_Int32 nRatio (100L * nNewSize / nOldSize);
 515         SAL_INFO("sd.sls", __func__ << ": compressing bitmap for " << %x << " from " << nOldSize << " to " << nNewSize << " bytes (" << nRatio << "%)");
 516 #endif
 517
 518         mpCompressor = rpCompressor;
 519     }
 520
 521     maPreview.SetEmpty();
 522     maMarkedPreview.SetEmpty();
 523 }
 524
 525 inline void BitmapCache::CacheEntry::Decompress()
 526 {
 527     if (mpReplacement != nullptr && mpCompressor != nullptr && maPreview.IsEmpty())
 528     {
 529         maPreview = mpCompressor->Decompress(*mpReplacement);
 530         maMarkedPreview.SetEmpty();
 531         if ( ! mpCompressor->IsLossless())
 532             mbIsUpToDate = false;
 533     }
 534 }
 535
 536 inline void BitmapCache::CacheEntry::SetPreview (const BitmapEx& rPreview)
 537 {
 538     maPreview = rPreview;
 539     maMarkedPreview.SetEmpty();
 540     mpReplacement.reset();
 541     mpCompressor.reset();
 542 }
 543
 544 bool BitmapCache::CacheEntry::HasPreview() const
 545 {
 546     return ! maPreview.IsEmpty();
 547 }
 548
 549 inline void BitmapCache::CacheEntry::SetMarkedPreview (const BitmapEx& rMarkedPreview)
 550 {
 551     maMarkedPreview = rMarkedPreview;
 552 }
 553
 554 inline bool BitmapCache::CacheEntry::HasLosslessReplacement() const
 555 {
 556     return mpReplacement != nullptr && mpCompressor != nullptr && mpCompressor->IsLossless();
 557 }
 558
 559 } // end of namespace ::sd::slidesorter::cache
 560
 561 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */