xbmc/GUILargeTextureManager.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "threads/SystemClock.h"
  22 #include "GUILargeTextureManager.h"
  23 #include "settings/Settings.h"
  24 #include "guilib/Texture.h"
  25 #include "threads/SingleLock.h"
  26 #include "utils/TimeUtils.h"
  27 #include "utils/JobManager.h"
  28 #include "guilib/GraphicContext.h"
  29 #include "utils/log.h"
  30 #include "TextureCache.h"
  31
  32 #include <cassert>
  33
  34 CImageLoader::CImageLoader(const std::string &path, const bool useCache):
  35   m_path(path)
  36 {
  37   m_texture = NULL;
  38   m_use_cache = useCache;
  39 }
  40
  41 CImageLoader::~CImageLoader()
  42 {
  43   delete(m_texture);
  44 }
  45
  46 bool CImageLoader::DoWork()
  47 {
  48   bool needsChecking = false;
  49   std::string loadPath;
  50
  51   std::string texturePath = g_TextureManager.GetTexturePath(m_path);
  52   if (texturePath.empty())
  53     return false;
  54
  55   if (m_use_cache)
  56     loadPath = CTextureCache::GetInstance().CheckCachedImage(texturePath, needsChecking);
  57   else
  58     loadPath = texturePath;
  59
  60   if (!loadPath.empty())
  61   {
  62     // direct route - load the image
  63     unsigned int start = XbmcThreads::SystemClockMillis();
  64     m_texture = CBaseTexture::LoadFromFile(loadPath, g_graphicsContext.GetWidth(), g_graphicsContext.GetHeight());
  65
  66     if (XbmcThreads::SystemClockMillis() - start > 100)
  67       CLog::Log(LOGDEBUG, "%s - took %u ms to load %s", __FUNCTION__, XbmcThreads::SystemClockMillis() - start, loadPath.c_str());
  68
  69     if (m_texture)
  70     {
  71       if (needsChecking)
  72         CTextureCache::GetInstance().BackgroundCacheImage(texturePath);
  73
  74       return true;
  75     }
  76
  77     // Fallthrough on failure:
  78     CLog::Log(LOGERROR, "%s - Direct texture file loading failed for %s", __FUNCTION__, loadPath.c_str());
  79   }
  80
  81   if (!m_use_cache)
  82     return false; // We're done
  83
  84   // not in our texture cache or it failed to load from it, so try and load directly and then cache the result
  85   CTextureCache::GetInstance().CacheImage(texturePath, &m_texture);
  86   return (m_texture != NULL);
  87 }
  88
  89 CGUILargeTextureManager::CLargeTexture::CLargeTexture(const std::string &path):
  90   m_path(path)
  91 {
  92   m_refCount = 1;
  93   m_timeToDelete = 0;
  94 }
  95
  96 CGUILargeTextureManager::CLargeTexture::~CLargeTexture()
  97 {
  98   assert(m_refCount == 0);
  99   m_texture.Free();
 100 }
 101
 102 void CGUILargeTextureManager::CLargeTexture::AddRef()
 103 {
 104   m_refCount++;
 105 }
 106
 107 bool CGUILargeTextureManager::CLargeTexture::DecrRef(bool deleteImmediately)
 108 {
 109   assert(m_refCount);
 110   m_refCount--;
 111   if (m_refCount == 0)
 112   {
 113     if (deleteImmediately)
 114       delete this;
 115     else
 116       m_timeToDelete = CTimeUtils::GetFrameTime() + TIME_TO_DELETE;
 117     return true;
 118   }
 119   return false;
 120 }
 121
 122 bool CGUILargeTextureManager::CLargeTexture::DeleteIfRequired(bool deleteImmediately)
 123 {
 124   if (m_refCount == 0 && (deleteImmediately || m_timeToDelete < CTimeUtils::GetFrameTime()))
 125   {
 126     delete this;
 127     return true;
 128   }
 129   return false;
 130 }
 131
 132 void CGUILargeTextureManager::CLargeTexture::SetTexture(CBaseTexture* texture)
 133 {
 134   assert(!m_texture.size());
 135   if (texture)
 136     m_texture.Set(texture, texture->GetWidth(), texture->GetHeight());
 137 }
 138
 139 CGUILargeTextureManager::CGUILargeTextureManager()
 140 {
 141 }
 142
 143 CGUILargeTextureManager::~CGUILargeTextureManager()
 144 {
 145 }
 146
 147 void CGUILargeTextureManager::CleanupUnusedImages(bool immediately)
 148 {
 149   CSingleLock lock(m_listSection);
 150   // check for items to remove from allocated list, and remove
 151   listIterator it = m_allocated.begin();
 152   while (it != m_allocated.end())
 153   {
 154     CLargeTexture *image = *it;
 155     if (image->DeleteIfRequired(immediately))
 156       it = m_allocated.erase(it);
 157     else
 158       ++it;
 159   }
 160 }
 161
 162 // if available, increment reference count, and return the image.
 163 // else, add to the queue list if appropriate.
 164 bool CGUILargeTextureManager::GetImage(const std::string &path, CTextureArray &texture, bool firstRequest, const bool useCache)
 165 {
 166   CSingleLock lock(m_listSection);
 167   for (listIterator it = m_allocated.begin(); it != m_allocated.end(); ++it)
 168   {
 169     CLargeTexture *image = *it;
 170     if (image->GetPath() == path)
 171     {
 172       if (firstRequest)
 173         image->AddRef();
 174       texture = image->GetTexture();
 175       return texture.size() > 0;
 176     }
 177   }
 178
 179   if (firstRequest)
 180     QueueImage(path, useCache);
 181
 182   return true;
 183 }
 184
 185 void CGUILargeTextureManager::ReleaseImage(const std::string &path, bool immediately)
 186 {
 187   CSingleLock lock(m_listSection);
 188   for (listIterator it = m_allocated.begin(); it != m_allocated.end(); ++it)
 189   {
 190     CLargeTexture *image = *it;
 191     if (image->GetPath() == path)
 192     {
 193       if (image->DecrRef(immediately) && immediately)
 194         m_allocated.erase(it);
 195       return;
 196     }
 197   }
 198   for (queueIterator it = m_queued.begin(); it != m_queued.end(); ++it)
 199   {
 200     unsigned int id = it->first;
 201     CLargeTexture *image = it->second;
 202     if (image->GetPath() == path && image->DecrRef(true))
 203     {
 204       // cancel this job
 205       CJobManager::GetInstance().CancelJob(id);
 206       m_queued.erase(it);
 207       return;
 208     }
 209   }
 210 }
 211
 212 // queue the image, and start the background loader if necessary
 213 void CGUILargeTextureManager::QueueImage(const std::string &path, bool useCache)
 214 {
 215   if (path.empty())
 216     return;
 217
 218   CSingleLock lock(m_listSection);
 219   for (queueIterator it = m_queued.begin(); it != m_queued.end(); ++it)
 220   {
 221     CLargeTexture *image = it->second;
 222     if (image->GetPath() == path)
 223     {
 224       image->AddRef();
 225       return; // already queued
 226     }
 227   }
 228
 229   // queue the item
 230   CLargeTexture *image = new CLargeTexture(path);
 231   unsigned int jobID = CJobManager::GetInstance().AddJob(new CImageLoader(path, useCache), this, CJob::PRIORITY_NORMAL);
 232   m_queued.push_back(std::make_pair(jobID, image));
 233 }
 234
 235 void CGUILargeTextureManager::OnJobComplete(unsigned int jobID, bool success, CJob *job)
 236 {
 237   // see if we still have this job id
 238   CSingleLock lock(m_listSection);
 239   for (queueIterator it = m_queued.begin(); it != m_queued.end(); ++it)
 240   {
 241     if (it->first == jobID)
 242     { // found our job
 243       CImageLoader *loader = (CImageLoader *)job;
 244       CLargeTexture *image = it->second;
 245       image->SetTexture(loader->m_texture);
 246       loader->m_texture = NULL; // we want to keep the texture, and jobs are auto-deleted.
 247       m_queued.erase(it);
 248       m_allocated.push_back(image);
 249       return;
 250     }
 251   }
 252 }