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 <memory>
  21 #include "SlsBitmapCache.hxx"
  22 #include "SlsCacheCompactor.hxx"
  23 #include "SlsBitmapCompressor.hxx"
  24 #include "SlsCacheConfiguration.hxx"
  25
  26 #include <sdpage.hxx>
  27 #include <drawdoc.hxx>
  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 static const sal_Int32 MAXIMAL_CACHE_SIZE = 4*1024L*1024L;
  35
  36 using namespace ::com::sun::star::uno;
  37
  38 namespace sd { namespace slidesorter { namespace 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 class CacheHash {
  81 public:
  82     size_t operator()(const BitmapCache::CacheKey& p) const
  83     { return reinterpret_cast<size_t>(p); }
  84 };
  85
  86 class BitmapCache::CacheBitmapContainer
  87     : public std::unordered_map<CacheKey, CacheEntry, CacheHash>
  88 {
  89 public:
  90     CacheBitmapContainer() {}
  91 };
  92
  93 namespace {
  94
  95 typedef ::std::vector<
  96     ::std::pair< ::sd::slidesorter::cache::BitmapCache::CacheKey,
  97       ::sd::slidesorter::cache::BitmapCache::CacheEntry>
  98     > SortableBitmapContainer;
  99
 100     /** Compare elements of the bitmap cache according to their last access
 101         time.
 102     */
 103     class AccessTimeComparator
 104     {
 105     public:
 106         bool operator () (
 107             const SortableBitmapContainer::value_type& e1,
 108             const SortableBitmapContainer::value_type& e2)
 109         {
 110             return e1.second.GetAccessTime() < e2.second.GetAccessTime();
 111         }
 112     };
 113
 114 } // end of anonymous namespace
 115
 116 //=====  BitmapCache  =========================================================
 117
 118 BitmapCache::BitmapCache ()
 119     : maMutex(),
 120       mpBitmapContainer(new CacheBitmapContainer()),
 121       mnNormalCacheSize(0),
 122       mnPreciousCacheSize(0),
 123       mnCurrentAccessTime(0),
 124       mnMaximalNormalCacheSize(MAXIMAL_CACHE_SIZE),
 125       mpCacheCompactor(),
 126       mbIsFull(false)
 127 {
 128     Any aCacheSize (CacheConfiguration::Instance()->GetValue("CacheSize"));
 129     if (aCacheSize.has<sal_Int32>())
 130         aCacheSize >>= mnMaximalNormalCacheSize;
 131
 132     mpCacheCompactor = CacheCompactor::Create(*this,mnMaximalNormalCacheSize);
 133 }
 134
 135 BitmapCache::~BitmapCache()
 136 {
 137     Clear();
 138 }
 139
 140 void BitmapCache::Clear()
 141 {
 142     ::osl::MutexGuard 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     ::osl::MutexGuard 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     ::osl::MutexGuard 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     ::osl::MutexGuard 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(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(iEntry->second, REMOVE);
 192             iEntry->second.Decompress();
 193             UpdateCacheSize(iEntry->second, ADD);
 194         }
 195     }
 196     return iEntry->second.GetPreview();
 197 }
 198
 199 BitmapEx BitmapCache::GetMarkedBitmap (const CacheKey& rKey)
 200 {
 201     ::osl::MutexGuard 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     ::osl::MutexGuard aGuard (maMutex);
 216
 217     CacheBitmapContainer::iterator aIterator (mpBitmapContainer->find(rKey));
 218     if (aIterator != mpBitmapContainer->end())
 219     {
 220         UpdateCacheSize(aIterator->second, REMOVE);
 221         mpBitmapContainer->erase(aIterator);
 222     }
 223 }
 224
 225 bool BitmapCache::InvalidateBitmap (const CacheKey& rKey)
 226 {
 227     ::osl::MutexGuard 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(iEntry->second, REMOVE);
 239             iEntry->second.Invalidate();
 240             UpdateCacheSize(iEntry->second, ADD);
 241         }
 242         return true;
 243     }
 244     else
 245         return false;
 246 }
 247
 248 void BitmapCache::InvalidateCache()
 249 {
 250     ::osl::MutexGuard aGuard (maMutex);
 251
 252     for (auto& rEntry : *mpBitmapContainer)
 253     {
 254         rEntry.second.Invalidate();
 255     }
 256     ReCalculateTotalCacheSize();
 257 }
 258
 259 void BitmapCache::SetBitmap (
 260     const CacheKey& rKey,
 261     const BitmapEx& rPreview,
 262     bool bIsPrecious)
 263 {
 264     ::osl::MutexGuard aGuard (maMutex);
 265
 266     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 267     if (iEntry != mpBitmapContainer->end())
 268     {
 269         UpdateCacheSize(iEntry->second, REMOVE);
 270         iEntry->second.SetPreview(rPreview);
 271         iEntry->second.SetUpToDate(true);
 272         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 273     }
 274     else
 275     {
 276         iEntry = mpBitmapContainer->emplace(
 277             rKey,
 278             CacheEntry(rPreview, mnCurrentAccessTime++, bIsPrecious)
 279             ).first;
 280     }
 281
 282     if (iEntry != mpBitmapContainer->end())
 283         UpdateCacheSize(iEntry->second, ADD);
 284 }
 285
 286 void BitmapCache::SetMarkedBitmap (
 287     const CacheKey& rKey,
 288     const BitmapEx& rPreview)
 289 {
 290     ::osl::MutexGuard aGuard (maMutex);
 291
 292     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 293     if (iEntry != mpBitmapContainer->end())
 294     {
 295         UpdateCacheSize(iEntry->second, REMOVE);
 296         iEntry->second.SetMarkedPreview(rPreview);
 297         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
 298         UpdateCacheSize(iEntry->second, ADD);
 299     }
 300 }
 301
 302 void BitmapCache::SetPrecious (const CacheKey& rKey, bool bIsPrecious)
 303 {
 304     ::osl::MutexGuard aGuard (maMutex);
 305
 306     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 307     if (iEntry != mpBitmapContainer->end())
 308     {
 309         if (iEntry->second.IsPrecious() != bIsPrecious)
 310         {
 311             UpdateCacheSize(iEntry->second, REMOVE);
 312             iEntry->second.SetPrecious(bIsPrecious);
 313             UpdateCacheSize(iEntry->second, ADD);
 314         }
 315     }
 316     else if (bIsPrecious)
 317     {
 318         iEntry = mpBitmapContainer->emplace(
 319             rKey,
 320             CacheEntry(BitmapEx(), mnCurrentAccessTime++, bIsPrecious)
 321             ).first;
 322         UpdateCacheSize(iEntry->second, ADD);
 323     }
 324 }
 325
 326 void BitmapCache::ReCalculateTotalCacheSize()
 327 {
 328     ::osl::MutexGuard aGuard (maMutex);
 329
 330     mnNormalCacheSize = 0;
 331     mnPreciousCacheSize = 0;
 332     for (const auto& rEntry : *mpBitmapContainer)
 333     {
 334         if (rEntry.second.IsPrecious())
 335             mnPreciousCacheSize += rEntry.second.GetMemorySize();
 336         else
 337             mnNormalCacheSize += rEntry.second.GetMemorySize();
 338     }
 339     mbIsFull = (mnNormalCacheSize  >= mnMaximalNormalCacheSize);
 340
 341     SAL_INFO("sd.sls", OSL_THIS_FUNC << ": cache size is " << mnNormalCacheSize << "/" << mnPreciousCacheSize);
 342 }
 343
 344 void BitmapCache::Recycle (const BitmapCache& rCache)
 345 {
 346     ::osl::MutexGuard aGuard (maMutex);
 347
 348     for (const auto& rOtherEntry : *rCache.mpBitmapContainer)
 349     {
 350         CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rOtherEntry.first));
 351         if (iEntry == mpBitmapContainer->end())
 352         {
 353             iEntry = mpBitmapContainer->emplace(
 354                 rOtherEntry.first,
 355                 CacheEntry(mnCurrentAccessTime++, true)
 356                 ).first;
 357             UpdateCacheSize(iEntry->second, ADD);
 358         }
 359         if (iEntry != mpBitmapContainer->end())
 360         {
 361             UpdateCacheSize(iEntry->second, REMOVE);
 362             iEntry->second.Recycle(rOtherEntry.second);
 363             UpdateCacheSize(iEntry->second, ADD);
 364         }
 365     }
 366 }
 367
 368 ::std::unique_ptr<BitmapCache::CacheIndex> BitmapCache::GetCacheIndex() const
 369 {
 370     ::osl::MutexGuard aGuard (maMutex);
 371
 372     // Create a copy of the bitmap container.
 373     SortableBitmapContainer aSortedContainer;
 374     aSortedContainer.reserve(mpBitmapContainer->size());
 375
 376     // Copy the relevant entries.
 377     for (const auto& rEntry : *mpBitmapContainer)
 378     {
 379         if ( rEntry.second.IsPrecious())
 380             continue;
 381
 382         if ( ! rEntry.second.HasPreview())
 383             continue;
 384
 385         aSortedContainer.emplace_back(rEntry.first, rEntry.second);
 386     }
 387
 388     // Sort the remaining entries.
 389     ::std::sort(aSortedContainer.begin(), aSortedContainer.end(), AccessTimeComparator());
 390
 391     // Return a list with the keys of the sorted entries.
 392     ::std::unique_ptr<CacheIndex> pIndex(new CacheIndex);
 393     pIndex->reserve(aSortedContainer.size());
 394     for (const auto& rIndexEntry : aSortedContainer)
 395         pIndex->push_back(rIndexEntry.first);
 396     return pIndex;
 397 }
 398
 399 void BitmapCache::Compress (
 400     const CacheKey& rKey,
 401     const std::shared_ptr<BitmapCompressor>& rpCompressor)
 402 {
 403     ::osl::MutexGuard aGuard (maMutex);
 404
 405     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
 406     if (iEntry != mpBitmapContainer->end() && iEntry->second.HasPreview())
 407     {
 408         UpdateCacheSize(iEntry->second, REMOVE);
 409         iEntry->second.Compress(rpCompressor);
 410         UpdateCacheSize(iEntry->second, ADD);
 411     }
 412 }
 413
 414 void BitmapCache::UpdateCacheSize (const CacheEntry& rEntry, CacheOperation eOperation)
 415 {
 416     sal_Int32 nEntrySize (rEntry.GetMemorySize());
 417     sal_Int32& rCacheSize (rEntry.IsPrecious() ? mnPreciousCacheSize : mnNormalCacheSize);
 418     switch (eOperation)
 419     {
 420         case ADD:
 421             rCacheSize += nEntrySize;
 422             if ( ! rEntry.IsPrecious() && mnNormalCacheSize>mnMaximalNormalCacheSize)
 423             {
 424                 mbIsFull = true;
 425                 SAL_INFO("sd.sls", OSL_THIS_FUNC << ": cache size is " << mnNormalCacheSize << " > " << mnMaximalNormalCacheSize);
 426                 mpCacheCompactor->RequestCompaction();
 427             }
 428             break;
 429
 430         case REMOVE:
 431             rCacheSize -= nEntrySize;
 432             if (mnNormalCacheSize < mnMaximalNormalCacheSize)
 433                 mbIsFull = false;
 434             break;
 435
 436         default:
 437             assert(false);
 438             break;
 439     }
 440 }
 441
 442 //===== CacheEntry ============================================================
 443
 444 BitmapCache::CacheEntry::CacheEntry(
 445     sal_Int32 nLastAccessTime,
 446     bool bIsPrecious)
 447     : maPreview(),
 448       maMarkedPreview(),
 449       mbIsUpToDate(true),
 450       mnLastAccessTime(nLastAccessTime),
 451       mbIsPrecious(bIsPrecious)
 452 {
 453 }
 454
 455 BitmapCache::CacheEntry::CacheEntry(
 456     const BitmapEx& rPreview,
 457     sal_Int32 nLastAccessTime,
 458     bool bIsPrecious)
 459     : maPreview(rPreview),
 460       maMarkedPreview(),
 461       mbIsUpToDate(true),
 462       mnLastAccessTime(nLastAccessTime),
 463       mbIsPrecious(bIsPrecious)
 464 {
 465 }
 466
 467 inline void BitmapCache::CacheEntry::Recycle (const CacheEntry& rEntry)
 468 {
 469     if ((rEntry.HasPreview() || rEntry.HasLosslessReplacement())
 470         && ! (HasPreview() || HasLosslessReplacement()))
 471     {
 472         maPreview = rEntry.maPreview;
 473         maMarkedPreview = rEntry.maMarkedPreview;
 474         mpReplacement = rEntry.mpReplacement;
 475         mpCompressor = rEntry.mpCompressor;
 476         mnLastAccessTime = rEntry.mnLastAccessTime;
 477         mbIsUpToDate = rEntry.mbIsUpToDate;
 478     }
 479 }
 480
 481 inline sal_Int32 BitmapCache::CacheEntry::GetMemorySize() const
 482 {
 483     sal_Int32 nSize (0);
 484     nSize += maPreview.GetSizeBytes();
 485     nSize += maMarkedPreview.GetSizeBytes();
 486     if (mpReplacement != nullptr)
 487         nSize += mpReplacement->GetMemorySize();
 488     return nSize;
 489 }
 490
 491 void BitmapCache::CacheEntry::Compress (const std::shared_ptr<BitmapCompressor>& rpCompressor)
 492 {
 493     if (  maPreview.IsEmpty())
 494         return;
 495
 496     if (mpReplacement == nullptr)
 497     {
 498         mpReplacement = rpCompressor->Compress(maPreview);
 499
 500 #ifdef DEBUG_SD_SLSBITMAPCACHE
 501         sal_uInt32 nOldSize (maPreview.GetSizeBytes());
 502         sal_uInt32 nNewSize (mpReplacement.get()!=NULL ? mpReplacement->GetMemorySize() : 0);
 503         if (nOldSize == 0)
 504             nOldSize = 1;
 505         sal_Int32 nRatio (100L * nNewSize / nOldSize);
 506         SAL_INFO("sd.sls", OSL_THIS_FUNC << ": compressing bitmap for " << %x << " from " << nOldSize << " to " << nNewSize << " bytes (" << nRatio << "%)");
 507 #endif
 508
 509         mpCompressor = rpCompressor;
 510     }
 511
 512     maPreview.SetEmpty();
 513     maMarkedPreview.SetEmpty();
 514 }
 515
 516 inline void BitmapCache::CacheEntry::Decompress()
 517 {
 518     if (mpReplacement != nullptr && mpCompressor != nullptr && maPreview.IsEmpty())
 519     {
 520         maPreview = mpCompressor->Decompress(*mpReplacement);
 521         maMarkedPreview.SetEmpty();
 522         if ( ! mpCompressor->IsLossless())
 523             mbIsUpToDate = false;
 524     }
 525 }
 526
 527 inline void BitmapCache::CacheEntry::SetPreview (const BitmapEx& rPreview)
 528 {
 529     maPreview = rPreview;
 530     maMarkedPreview.SetEmpty();
 531     mpReplacement.reset();
 532     mpCompressor.reset();
 533 }
 534
 535 bool BitmapCache::CacheEntry::HasPreview() const
 536 {
 537     return ! maPreview.IsEmpty();
 538 }
 539
 540 inline void BitmapCache::CacheEntry::SetMarkedPreview (const BitmapEx& rMarkedPreview)
 541 {
 542     maMarkedPreview = rMarkedPreview;
 543 }
 544
 545 inline bool BitmapCache::CacheEntry::HasLosslessReplacement() const
 546 {
 547     return mpReplacement != nullptr && mpCompressor != nullptr && mpCompressor->IsLossless();
 548 }
 549
 550 } } } // end of namespace ::sd::slidesorter::cache
 551
 552 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */