xbmc/TextureCache.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "TextureCache.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "TextureCacheJob.h"
  13 #include "URL.h"
  14 #include "commons/ilog.h"
  15 #include "filesystem/File.h"
  16 #include "filesystem/IFileTypes.h"
  17 #include "guilib/Texture.h"
  18 #include "profiles/ProfileManager.h"
  19 #include "settings/SettingsComponent.h"
  20 #include "utils/Crc32.h"
  21 #include "utils/Job.h"
  22 #include "utils/StringUtils.h"
  23 #include "utils/URIUtils.h"
  24 #include "utils/log.h"
  25
  26 #include <chrono>
  27 #include <exception>
  28 #include <mutex>
  29 #include <string.h>
  30
  31 using namespace XFILE;
  32 using namespace std::chrono_literals;
  33
  34 CTextureCache::CTextureCache() : CJobQueue(false, 1, CJob::PRIORITY_LOW_PAUSABLE)
  35 {
  36 }
  37
  38 CTextureCache::~CTextureCache() = default;
  39
  40 void CTextureCache::Initialize()
  41 {
  42   std::unique_lock<CCriticalSection> lock(m_databaseSection);
  43   if (!m_database.IsOpen())
  44     m_database.Open();
  45 }
  46
  47 void CTextureCache::Deinitialize()
  48 {
  49   CancelJobs();
  50
  51   std::unique_lock<CCriticalSection> lock(m_databaseSection);
  52   m_database.Close();
  53 }
  54
  55 bool CTextureCache::IsCachedImage(const std::string &url) const
  56 {
  57   if (url.empty())
  58     return false;
  59
  60   if (!CURL::IsFullPath(url))
  61     return true;
  62
  63   const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
  64
  65   return URIUtils::PathHasParent(url, "special://skin", true) ||
  66       URIUtils::PathHasParent(url, "special://temp", true) ||
  67       URIUtils::PathHasParent(url, "resource://", true) ||
  68       URIUtils::PathHasParent(url, "androidapp://", true)   ||
  69       URIUtils::PathHasParent(url, profileManager->GetThumbnailsFolder(), true);
  70 }
  71
  72 bool CTextureCache::HasCachedImage(const std::string &url)
  73 {
  74   CTextureDetails details;
  75   std::string cachedImage(GetCachedImage(url, details));
  76   return (!cachedImage.empty() && cachedImage != url);
  77 }
  78
  79 std::string CTextureCache::GetCachedImage(const std::string &image, CTextureDetails &details, bool trackUsage)
  80 {
  81   std::string url = CTextureUtils::UnwrapImageURL(image);
  82   if (url.empty())
  83     return "";
  84   if (IsCachedImage(url))
  85     return url;
  86
  87   // lookup the item in the database
  88   if (GetCachedTexture(url, details))
  89   {
  90     if (trackUsage)
  91       IncrementUseCount(details);
  92     return GetCachedPath(details.file);
  93   }
  94   return "";
  95 }
  96
  97 bool CTextureCache::CanCacheImageURL(const CURL &url)
  98 {
  99   return url.GetUserName().empty() || url.GetUserName() == "music" ||
 100          StringUtils::StartsWith(url.GetUserName(), "video_") ||
 101          StringUtils::StartsWith(url.GetUserName(), "pvr") ||
 102          StringUtils::StartsWith(url.GetUserName(), "epg");
 103 }
 104
 105 std::string CTextureCache::CheckCachedImage(const std::string &url, bool &needsRecaching)
 106 {
 107   CTextureDetails details;
 108   std::string path(GetCachedImage(url, details, true));
 109   needsRecaching = !details.hash.empty();
 110   if (!path.empty())
 111     return path;
 112   return "";
 113 }
 114
 115 void CTextureCache::BackgroundCacheImage(const std::string &url)
 116 {
 117   if (url.empty())
 118     return;
 119
 120   CTextureDetails details;
 121   std::string path(GetCachedImage(url, details));
 122   if (!path.empty() && details.hash.empty())
 123     return; // image is already cached and doesn't need to be checked further
 124
 125   path = CTextureUtils::UnwrapImageURL(url);
 126   if (path.empty())
 127     return;
 128
 129   // needs (re)caching
 130   AddJob(new CTextureCacheJob(path, details.hash));
 131 }
 132
 133 bool CTextureCache::StartCacheImage(const std::string& image)
 134 {
 135   std::unique_lock<CCriticalSection> lock(m_processingSection);
 136   std::set<std::string>::iterator i = m_processinglist.find(image);
 137   if (i == m_processinglist.end())
 138   {
 139     m_processinglist.insert(image);
 140     return true;
 141   }
 142   return false;
 143 }
 144
 145 std::string CTextureCache::CacheImage(const std::string& image,
 146                                       std::unique_ptr<CTexture>* texture /*= nullptr*/,
 147                                       CTextureDetails* details /*= nullptr*/)
 148 {
 149   std::string url = CTextureUtils::UnwrapImageURL(image);
 150   if (url.empty())
 151     return "";
 152
 153   std::unique_lock<CCriticalSection> lock(m_processingSection);
 154   if (m_processinglist.find(url) == m_processinglist.end())
 155   {
 156     m_processinglist.insert(url);
 157     lock.unlock();
 158     // cache the texture directly
 159     CTextureCacheJob job(url);
 160     bool success = job.CacheTexture(texture);
 161     OnCachingComplete(success, &job);
 162     if (success && details)
 163       *details = job.m_details;
 164     return success ? GetCachedPath(job.m_details.file) : "";
 165   }
 166   lock.unlock();
 167
 168   // wait for currently processing job to end.
 169   while (true)
 170   {
 171     m_completeEvent.Wait(1000ms);
 172     {
 173       std::unique_lock<CCriticalSection> lock(m_processingSection);
 174       if (m_processinglist.find(url) == m_processinglist.end())
 175         break;
 176     }
 177   }
 178   CTextureDetails tempDetails;
 179   if (!details)
 180     details = &tempDetails;
 181
 182   std::string cachedpath = GetCachedImage(url, *details, true);
 183   if (!cachedpath.empty())
 184   {
 185     if (texture)
 186       *texture = CTexture::LoadFromFile(cachedpath, 0, 0);
 187   }
 188   else
 189   {
 190     CLog::Log(LOGDEBUG, "CTextureCache::{} - Return NULL texture because cache is not ready",
 191               __FUNCTION__);
 192   }
 193
 194   return cachedpath;
 195 }
 196
 197 bool CTextureCache::CacheImage(const std::string &image, CTextureDetails &details)
 198 {
 199   std::string path = GetCachedImage(image, details);
 200   if (path.empty()) // not cached
 201     path = CacheImage(image, NULL, &details);
 202
 203   return !path.empty();
 204 }
 205
 206 void CTextureCache::ClearCachedImage(const std::string &url, bool deleteSource /*= false */)
 207 {
 208   //! @todo This can be removed when the texture cache covers everything.
 209   std::string path = deleteSource ? url : "";
 210   std::string cachedFile;
 211   if (ClearCachedTexture(url, cachedFile))
 212     path = GetCachedPath(cachedFile);
 213   if (CFile::Exists(path))
 214     CFile::Delete(path);
 215   path = URIUtils::ReplaceExtension(path, ".dds");
 216   if (CFile::Exists(path))
 217     CFile::Delete(path);
 218 }
 219
 220 bool CTextureCache::ClearCachedImage(int id)
 221 {
 222   std::string cachedFile;
 223   if (ClearCachedTexture(id, cachedFile))
 224   {
 225     cachedFile = GetCachedPath(cachedFile);
 226     if (CFile::Exists(cachedFile))
 227       CFile::Delete(cachedFile);
 228     cachedFile = URIUtils::ReplaceExtension(cachedFile, ".dds");
 229     if (CFile::Exists(cachedFile))
 230       CFile::Delete(cachedFile);
 231     return true;
 232   }
 233   return false;
 234 }
 235
 236 bool CTextureCache::GetCachedTexture(const std::string &url, CTextureDetails &details)
 237 {
 238   std::unique_lock<CCriticalSection> lock(m_databaseSection);
 239   return m_database.GetCachedTexture(url, details);
 240 }
 241
 242 bool CTextureCache::AddCachedTexture(const std::string &url, const CTextureDetails &details)
 243 {
 244   std::unique_lock<CCriticalSection> lock(m_databaseSection);
 245   return m_database.AddCachedTexture(url, details);
 246 }
 247
 248 void CTextureCache::IncrementUseCount(const CTextureDetails &details)
 249 {
 250   static const size_t count_before_update = 100;
 251   std::unique_lock<CCriticalSection> lock(m_useCountSection);
 252   m_useCounts.reserve(count_before_update);
 253   m_useCounts.push_back(details);
 254   if (m_useCounts.size() >= count_before_update)
 255   {
 256     AddJob(new CTextureUseCountJob(m_useCounts));
 257     m_useCounts.clear();
 258   }
 259 }
 260
 261 bool CTextureCache::SetCachedTextureValid(const std::string &url, bool updateable)
 262 {
 263   std::unique_lock<CCriticalSection> lock(m_databaseSection);
 264   return m_database.SetCachedTextureValid(url, updateable);
 265 }
 266
 267 bool CTextureCache::ClearCachedTexture(const std::string &url, std::string &cachedURL)
 268 {
 269   std::unique_lock<CCriticalSection> lock(m_databaseSection);
 270   return m_database.ClearCachedTexture(url, cachedURL);
 271 }
 272
 273 bool CTextureCache::ClearCachedTexture(int id, std::string &cachedURL)
 274 {
 275   std::unique_lock<CCriticalSection> lock(m_databaseSection);
 276   return m_database.ClearCachedTexture(id, cachedURL);
 277 }
 278
 279 std::string CTextureCache::GetCacheFile(const std::string &url)
 280 {
 281   auto crc = Crc32::ComputeFromLowerCase(url);
 282   std::string hex = StringUtils::Format("{:08x}", crc);
 283   std::string hash = StringUtils::Format("{}/{}", hex[0], hex.c_str());
 284   return hash;
 285 }
 286
 287 std::string CTextureCache::GetCachedPath(const std::string &file)
 288 {
 289   const std::shared_ptr<CProfileManager> profileManager = CServiceBroker::GetSettingsComponent()->GetProfileManager();
 290
 291   return URIUtils::AddFileToFolder(profileManager->GetThumbnailsFolder(), file);
 292 }
 293
 294 void CTextureCache::OnCachingComplete(bool success, CTextureCacheJob *job)
 295 {
 296   if (success)
 297   {
 298     if (job->m_oldHash == job->m_details.hash)
 299       SetCachedTextureValid(job->m_url, job->m_details.updateable);
 300     else
 301       AddCachedTexture(job->m_url, job->m_details);
 302   }
 303
 304   { // remove from our processing list
 305     std::unique_lock<CCriticalSection> lock(m_processingSection);
 306     std::set<std::string>::iterator i = m_processinglist.find(job->m_url);
 307     if (i != m_processinglist.end())
 308       m_processinglist.erase(i);
 309   }
 310
 311   m_completeEvent.Set();
 312 }
 313
 314 void CTextureCache::OnJobComplete(unsigned int jobID, bool success, CJob *job)
 315 {
 316   if (strcmp(job->GetType(), kJobTypeCacheImage) == 0)
 317     OnCachingComplete(success, static_cast<CTextureCacheJob*>(job));
 318   return CJobQueue::OnJobComplete(jobID, success, job);
 319 }
 320
 321 bool CTextureCache::Export(const std::string &image, const std::string &destination, bool overwrite)
 322 {
 323   CTextureDetails details;
 324   std::string cachedImage(GetCachedImage(image, details));
 325   if (!cachedImage.empty())
 326   {
 327     std::string dest = destination + URIUtils::GetExtension(cachedImage);
 328     if (overwrite || !CFile::Exists(dest))
 329     {
 330       if (CFile::Copy(cachedImage, dest))
 331         return true;
 332       CLog::Log(LOGERROR, "{} failed exporting '{}' to '{}'", __FUNCTION__, cachedImage, dest);
 333     }
 334   }
 335   return false;
 336 }
 337
 338 bool CTextureCache::Export(const std::string &image, const std::string &destination)
 339 {
 340   CTextureDetails details;
 341   std::string cachedImage(GetCachedImage(image, details));
 342   if (!cachedImage.empty())
 343   {
 344     if (CFile::Copy(cachedImage, destination))
 345       return true;
 346     CLog::Log(LOGERROR, "{} failed exporting '{}' to '{}'", __FUNCTION__, cachedImage, destination);
 347   }
 348   return false;
 349 }