xbmc/guilib/TextureManager.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 "TextureManager.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "Texture.h"
  13 #include "URL.h"
  14 #include "commons/ilog.h"
  15 #include "filesystem/Directory.h"
  16 #include "filesystem/File.h"
  17 #include "guilib/TextureBundle.h"
  18 #include "guilib/TextureFormats.h"
  19 #include "utils/StringUtils.h"
  20 #include "utils/URIUtils.h"
  21 #include "utils/log.h"
  22 #include "windowing/GraphicContext.h"
  23 #include "windowing/WinSystem.h"
  24
  25 #include <mutex>
  26
  27 #ifdef _DEBUG_TEXTURES
  28 #include "utils/TimeUtils.h"
  29 #endif
  30 #if defined(TARGET_DARWIN_IOS)
  31 #define WIN_SYSTEM_CLASS CWinSystemIOS
  32 #include "windowing/ios/WinSystemIOS.h" // for g_Windowing in CGUITextureManager::FreeUnusedTextures
  33 #elif defined(TARGET_DARWIN_TVOS)
  34 #define WIN_SYSTEM_CLASS CWinSystemTVOS
  35 #include "windowing/tvos/WinSystemTVOS.h" // for g_Windowing in CGUITextureManager::FreeUnusedTextures
  36 #endif
  37
  38 #if defined(HAS_GL) || defined(HAS_GLES)
  39 #include "system_gl.h"
  40 #endif
  41
  42 #include "FFmpegImage.h"
  43
  44 #include <algorithm>
  45 #include <cassert>
  46 #include <exception>
  47
  48 /************************************************************************/
  49 /*                                                                      */
  50 /************************************************************************/
  51 CTextureArray::CTextureArray(int width, int height, int loops,  bool texCoordsArePixels)
  52 {
  53   m_width = width;
  54   m_height = height;
  55   m_loops = loops;
  56   m_orientation = 0;
  57   m_texWidth = 0;
  58   m_texHeight = 0;
  59   m_texCoordsArePixels = false;
  60 }
  61
  62 CTextureArray::CTextureArray()
  63 {
  64   Reset();
  65 }
  66
  67 CTextureArray::~CTextureArray() = default;
  68
  69 unsigned int CTextureArray::size() const
  70 {
  71   return m_textures.size();
  72 }
  73
  74
  75 void CTextureArray::Reset()
  76 {
  77   m_textures.clear();
  78   m_delays.clear();
  79   m_width = 0;
  80   m_height = 0;
  81   m_loops = 0;
  82   m_orientation = 0;
  83   m_texWidth = 0;
  84   m_texHeight = 0;
  85   m_texCoordsArePixels = false;
  86 }
  87
  88 void CTextureArray::Add(std::shared_ptr<CTexture> texture, int delay)
  89 {
  90   if (!texture)
  91     return;
  92
  93   m_texWidth = texture->GetTextureWidth();
  94   m_texHeight = texture->GetTextureHeight();
  95   m_texCoordsArePixels = false;
  96
  97   m_textures.emplace_back(std::move(texture));
  98   m_delays.push_back(delay);
  99 }
 100
 101 void CTextureArray::Set(std::shared_ptr<CTexture> texture, int width, int height)
 102 {
 103   assert(!m_textures.size()); // don't try and set a texture if we already have one!
 104   m_width = width;
 105   m_height = height;
 106   m_orientation = texture ? texture->GetOrientation() : 0;
 107   Add(std::move(texture), 2);
 108 }
 109
 110 void CTextureArray::Free()
 111 {
 112   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 113   Reset();
 114 }
 115
 116
 117 /************************************************************************/
 118 /*                                                                      */
 119 /************************************************************************/
 120
 121 CTextureMap::CTextureMap()
 122 {
 123   m_referenceCount = 0;
 124   m_memUsage = 0;
 125 }
 126
 127 CTextureMap::CTextureMap(const std::string& textureName, int width, int height, int loops)
 128 : m_texture(width, height, loops)
 129 , m_textureName(textureName)
 130 {
 131   m_referenceCount = 0;
 132   m_memUsage = 0;
 133 }
 134
 135 CTextureMap::~CTextureMap()
 136 {
 137   FreeTexture();
 138 }
 139
 140 bool CTextureMap::Release()
 141 {
 142   if (!m_texture.m_textures.size())
 143     return true;
 144   if (!m_referenceCount)
 145     return true;
 146
 147   m_referenceCount--;
 148   if (!m_referenceCount)
 149   {
 150     return true;
 151   }
 152   return false;
 153 }
 154
 155 const std::string& CTextureMap::GetName() const
 156 {
 157   return m_textureName;
 158 }
 159
 160 const CTextureArray& CTextureMap::GetTexture()
 161 {
 162   m_referenceCount++;
 163   return m_texture;
 164 }
 165
 166 void CTextureMap::Dump() const
 167 {
 168   if (!m_referenceCount)
 169     return;   // nothing to see here
 170
 171   CLog::Log(LOGDEBUG, "{0}: texture:{1} has {2} frames {3} refcount", __FUNCTION__, m_textureName,
 172             m_texture.m_textures.size(), m_referenceCount);
 173 }
 174
 175 unsigned int CTextureMap::GetMemoryUsage() const
 176 {
 177   return m_memUsage;
 178 }
 179
 180 void CTextureMap::Flush()
 181 {
 182   if (!m_referenceCount)
 183     FreeTexture();
 184 }
 185
 186
 187 void CTextureMap::FreeTexture()
 188 {
 189   m_texture.Free();
 190 }
 191
 192 void CTextureMap::SetHeight(int height)
 193 {
 194   m_texture.m_height = height;
 195 }
 196
 197 void CTextureMap::SetWidth(int height)
 198 {
 199   m_texture.m_width = height;
 200 }
 201
 202 bool CTextureMap::IsEmpty() const
 203 {
 204   return m_texture.m_textures.empty();
 205 }
 206
 207 void CTextureMap::Add(std::unique_ptr<CTexture> texture, int delay)
 208 {
 209   if (texture)
 210     m_memUsage += sizeof(CTexture) + (texture->GetTextureWidth() * texture->GetTextureHeight() * 4);
 211
 212   m_texture.Add(std::move(texture), delay);
 213 }
 214
 215 /************************************************************************/
 216 /*                                                                      */
 217 /************************************************************************/
 218 CGUITextureManager::CGUITextureManager(void)
 219 {
 220   // we set the theme bundle to be the first bundle (thus prioritizing it)
 221   m_TexBundle[0].SetThemeBundle(true);
 222 }
 223
 224 CGUITextureManager::~CGUITextureManager(void)
 225 {
 226   Cleanup();
 227 }
 228
 229 /************************************************************************/
 230 /*                                                                      */
 231 /************************************************************************/
 232 bool CGUITextureManager::CanLoad(const std::string &texturePath)
 233 {
 234   if (texturePath.empty())
 235     return false;
 236
 237   if (!CURL::IsFullPath(texturePath))
 238     return true;  // assume we have it
 239
 240   // we can't (or shouldn't) be loading from remote paths, so check these
 241   return URIUtils::IsHD(texturePath);
 242 }
 243
 244 bool CGUITextureManager::HasTexture(const std::string &textureName, std::string *path, int *bundle, int *size)
 245 {
 246   std::unique_lock<CCriticalSection> lock(m_section);
 247
 248   // default values
 249   if (bundle) *bundle = -1;
 250   if (size) *size = 0;
 251   if (path) *path = textureName;
 252
 253   if (textureName.empty())
 254     return false;
 255
 256   if (!CanLoad(textureName))
 257     return false;
 258
 259   // Check our loaded and bundled textures - we store in bundles using \\.
 260   std::string bundledName = CTextureBundle::Normalize(textureName);
 261   for (int i = 0; i < (int)m_vecTextures.size(); ++i)
 262   {
 263     CTextureMap *pMap = m_vecTextures[i];
 264     if (pMap->GetName() == textureName)
 265     {
 266       if (size) *size = 1;
 267       return true;
 268     }
 269   }
 270
 271   for (int i = 0; i < 2; i++)
 272   {
 273     if (m_TexBundle[i].HasFile(bundledName))
 274     {
 275       if (bundle) *bundle = i;
 276       return true;
 277     }
 278   }
 279
 280   std::string fullPath = GetTexturePath(textureName);
 281   if (path)
 282     *path = fullPath;
 283
 284   return !fullPath.empty();
 285 }
 286
 287 const CTextureArray& CGUITextureManager::Load(const std::string& strTextureName, bool checkBundleOnly /*= false */)
 288 {
 289   std::string strPath;
 290   static CTextureArray emptyTexture;
 291   int bundle = -1;
 292   int size = 0;
 293
 294   if (strTextureName.empty())
 295     return emptyTexture;
 296
 297   if (!HasTexture(strTextureName, &strPath, &bundle, &size))
 298     return emptyTexture;
 299
 300   if (size) // we found the texture
 301   {
 302     for (int i = 0; i < (int)m_vecTextures.size(); ++i)
 303     {
 304       CTextureMap *pMap = m_vecTextures[i];
 305       if (pMap->GetName() == strTextureName)
 306       {
 307         //CLog::Log(LOGDEBUG, "Total memusage {}", GetMemoryUsage());
 308         return pMap->GetTexture();
 309       }
 310     }
 311     // Whoops, not there.
 312     return emptyTexture;
 313   }
 314
 315   for (auto i = m_unusedTextures.begin(); i != m_unusedTextures.end(); ++i)
 316   {
 317     CTextureMap* pMap = i->first;
 318
 319     auto timestamp = i->second.time_since_epoch();
 320     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(timestamp);
 321
 322     if (pMap->GetName() == strTextureName && duration.count() > 0)
 323     {
 324       m_vecTextures.push_back(pMap);
 325       m_unusedTextures.erase(i);
 326       return pMap->GetTexture();
 327     }
 328   }
 329
 330   if (checkBundleOnly && bundle == -1)
 331     return emptyTexture;
 332
 333   //Lock here, we will do stuff that could break rendering
 334   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 335
 336 #ifdef _DEBUG_TEXTURES
 337   const auto start = std::chrono::steady_clock::now();
 338 #endif
 339
 340   if (bundle >= 0 && StringUtils::EndsWithNoCase(strPath, ".gif"))
 341   {
 342     CTextureMap* pMap = nullptr;
 343     std::vector<std::pair<std::unique_ptr<CTexture>, int>> textures;
 344     int nLoops = 0, width = 0, height = 0;
 345     bool success = m_TexBundle[bundle].LoadAnim(strTextureName, textures, width, height, nLoops);
 346     if (!success)
 347     {
 348       CLog::Log(LOGERROR, "Texture manager unable to load bundled file: {}", strTextureName);
 349       return emptyTexture;
 350     }
 351
 352     unsigned int maxWidth = 0;
 353     unsigned int maxHeight = 0;
 354     pMap = new CTextureMap(strTextureName, width, height, nLoops);
 355     for (auto& texture : textures)
 356     {
 357       maxWidth = std::max(maxWidth, texture.first->GetWidth());
 358       maxHeight = std::max(maxHeight, texture.first->GetHeight());
 359       pMap->Add(std::move(texture.first), texture.second);
 360     }
 361
 362     pMap->SetWidth((int)maxWidth);
 363     pMap->SetHeight((int)maxHeight);
 364
 365     m_vecTextures.push_back(pMap);
 366     return pMap->GetTexture();
 367   }
 368   else if (StringUtils::EndsWithNoCase(strPath, ".gif") ||
 369            StringUtils::EndsWithNoCase(strPath, ".apng"))
 370   {
 371     std::string mimeType;
 372     if (StringUtils::EndsWithNoCase(strPath, ".gif"))
 373       mimeType = "image/gif";
 374     else if (StringUtils::EndsWithNoCase(strPath, ".apng"))
 375       mimeType = "image/apng";
 376
 377     XFILE::CFile file;
 378     std::vector<uint8_t> buf;
 379     CFFmpegImage anim(mimeType);
 380
 381     if (file.LoadFile(strPath, buf) <= 0 || !anim.Initialize(buf.data(), buf.size()))
 382     {
 383       CLog::Log(LOGERROR, "Texture manager unable to load file: {}", CURL::GetRedacted(strPath));
 384       file.Close();
 385       return emptyTexture;
 386     }
 387
 388     CTextureMap* pMap = new CTextureMap(strTextureName, 0, 0, 0);
 389     unsigned int maxWidth = 0;
 390     unsigned int maxHeight = 0;
 391     uint64_t maxMemoryUsage = 91238400;// 1920*1080*4*11 bytes, i.e, a total of approx. 12 full hd frames
 392
 393     auto frame = anim.ReadFrame();
 394     while (frame)
 395     {
 396       std::unique_ptr<CTexture> glTexture = CTexture::CreateTexture();
 397       if (glTexture)
 398       {
 399         glTexture->LoadFromMemory(anim.Width(), anim.Height(), frame->GetPitch(), XB_FMT_A8R8G8B8, true, frame->m_pImage);
 400         maxWidth = std::max(maxWidth, glTexture->GetWidth());
 401         maxHeight = std::max(maxHeight, glTexture->GetHeight());
 402         pMap->Add(std::move(glTexture), frame->m_delay);
 403       }
 404
 405       if (pMap->GetMemoryUsage() <= maxMemoryUsage)
 406       {
 407         frame = anim.ReadFrame();
 408       }
 409       else
 410       {
 411         CLog::Log(LOGDEBUG, "Memory limit ({} bytes) exceeded, {} frames extracted from file : {}",
 412                   (maxMemoryUsage / 11) * 12, pMap->GetTexture().size(),
 413                   CURL::GetRedacted(strPath));
 414         break;
 415       }
 416     }
 417
 418     pMap->SetWidth((int)maxWidth);
 419     pMap->SetHeight((int)maxHeight);
 420
 421     file.Close();
 422
 423     m_vecTextures.push_back(pMap);
 424     return pMap->GetTexture();
 425   }
 426
 427   std::unique_ptr<CTexture> pTexture;
 428   int width = 0, height = 0;
 429   if (bundle >= 0)
 430   {
 431     if (!m_TexBundle[bundle].LoadTexture(strTextureName, pTexture, width, height))
 432     {
 433       CLog::Log(LOGERROR, "Texture manager unable to load bundled file: {}", strTextureName);
 434       return emptyTexture;
 435     }
 436   }
 437   else
 438   {
 439     pTexture = CTexture::LoadFromFile(strPath);
 440     if (!pTexture)
 441       return emptyTexture;
 442     width = pTexture->GetWidth();
 443     height = pTexture->GetHeight();
 444   }
 445
 446   if (!pTexture) return emptyTexture;
 447
 448   CTextureMap* pMap = new CTextureMap(strTextureName, width, height, 0);
 449   pMap->Add(std::move(pTexture), 100);
 450   m_vecTextures.push_back(pMap);
 451
 452 #ifdef _DEBUG_TEXTURES
 453   const auto end = std::chrono::steady_clock::now();
 454   const std::chrono::duration<double, std::milli> duration = end - start;
 455   CLog::Log(LOGDEBUG, "Load {}: {:.3f} ms {}", strPath, duration.count(),
 456             (bundle >= 0) ? "(bundled)" : "");
 457 #endif
 458
 459   return pMap->GetTexture();
 460 }
 461
 462
 463 void CGUITextureManager::ReleaseTexture(const std::string& strTextureName, bool immediately /*= false */)
 464 {
 465   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 466
 467   ivecTextures i;
 468   i = m_vecTextures.begin();
 469   while (i != m_vecTextures.end())
 470   {
 471     CTextureMap* pMap = *i;
 472     if (pMap->GetName() == strTextureName)
 473     {
 474       if (pMap->Release())
 475       {
 476         //CLog::Log(LOGINFO, "  cleanup:{}", strTextureName);
 477         // add to our textures to free
 478         std::chrono::time_point<std::chrono::steady_clock> timestamp;
 479
 480         if (!immediately)
 481           timestamp = std::chrono::steady_clock::now();
 482
 483         m_unusedTextures.emplace_back(pMap, timestamp);
 484         i = m_vecTextures.erase(i);
 485       }
 486       return;
 487     }
 488     ++i;
 489   }
 490   CLog::Log(LOGWARNING, "{}: Unable to release texture {}", __FUNCTION__, strTextureName);
 491 }
 492
 493 void CGUITextureManager::FreeUnusedTextures(unsigned int timeDelay)
 494 {
 495   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 496   for (auto i = m_unusedTextures.begin(); i != m_unusedTextures.end();)
 497   {
 498     auto now = std::chrono::steady_clock::now();
 499     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now - i->second);
 500
 501     if (duration.count() >= timeDelay)
 502     {
 503       delete i->first;
 504       i = m_unusedTextures.erase(i);
 505     }
 506     else
 507       ++i;
 508   }
 509
 510 #if defined(HAS_GL) || defined(HAS_GLES)
 511   for (unsigned int i = 0; i < m_unusedHwTextures.size(); ++i)
 512   {
 513     // on ios/tvos the hw textures might be deleted from the os
 514     // when XBMC is backgrounded (e.x. for backgrounded music playback)
 515     // sanity check before delete in that case.
 516 #if defined(TARGET_DARWIN_EMBEDDED)
 517     auto winSystem = dynamic_cast<WIN_SYSTEM_CLASS*>(CServiceBroker::GetWinSystem());
 518     if (!winSystem->IsBackgrounded() || glIsTexture(m_unusedHwTextures[i]))
 519 #endif
 520       glDeleteTextures(1, (GLuint*) &m_unusedHwTextures[i]);
 521   }
 522 #endif
 523   m_unusedHwTextures.clear();
 524 }
 525
 526 void CGUITextureManager::ReleaseHwTexture(unsigned int texture)
 527 {
 528   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 529   m_unusedHwTextures.push_back(texture);
 530 }
 531
 532 void CGUITextureManager::Cleanup()
 533 {
 534   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 535
 536   ivecTextures i;
 537   i = m_vecTextures.begin();
 538   while (i != m_vecTextures.end())
 539   {
 540     CTextureMap* pMap = *i;
 541     CLog::Log(LOGWARNING, "{}: Having to cleanup texture {}", __FUNCTION__, pMap->GetName());
 542     delete pMap;
 543     i = m_vecTextures.erase(i);
 544   }
 545   m_TexBundle[0].Close();
 546   m_TexBundle[1].Close();
 547   m_TexBundle[0] = CTextureBundle(true);
 548   m_TexBundle[1] = CTextureBundle();
 549   FreeUnusedTextures();
 550 }
 551
 552 void CGUITextureManager::Dump() const
 553 {
 554   CLog::Log(LOGDEBUG, "{0}: total texturemaps size: {1}", __FUNCTION__, m_vecTextures.size());
 555
 556   for (int i = 0; i < (int)m_vecTextures.size(); ++i)
 557   {
 558     const CTextureMap* pMap = m_vecTextures[i];
 559     if (!pMap->IsEmpty())
 560       pMap->Dump();
 561   }
 562 }
 563
 564 void CGUITextureManager::Flush()
 565 {
 566   std::unique_lock<CCriticalSection> lock(CServiceBroker::GetWinSystem()->GetGfxContext());
 567
 568   ivecTextures i;
 569   i = m_vecTextures.begin();
 570   while (i != m_vecTextures.end())
 571   {
 572     CTextureMap* pMap = *i;
 573     pMap->Flush();
 574     if (pMap->IsEmpty() )
 575     {
 576       delete pMap;
 577       i = m_vecTextures.erase(i);
 578     }
 579     else
 580     {
 581       ++i;
 582     }
 583   }
 584 }
 585
 586 unsigned int CGUITextureManager::GetMemoryUsage() const
 587 {
 588   unsigned int memUsage = 0;
 589   for (int i = 0; i < (int)m_vecTextures.size(); ++i)
 590   {
 591     memUsage += m_vecTextures[i]->GetMemoryUsage();
 592   }
 593   return memUsage;
 594 }
 595
 596 void CGUITextureManager::SetTexturePath(const std::string &texturePath)
 597 {
 598   std::unique_lock<CCriticalSection> lock(m_section);
 599   m_texturePaths.clear();
 600   AddTexturePath(texturePath);
 601 }
 602
 603 void CGUITextureManager::AddTexturePath(const std::string &texturePath)
 604 {
 605   std::unique_lock<CCriticalSection> lock(m_section);
 606   if (!texturePath.empty())
 607     m_texturePaths.push_back(texturePath);
 608 }
 609
 610 void CGUITextureManager::RemoveTexturePath(const std::string &texturePath)
 611 {
 612   std::unique_lock<CCriticalSection> lock(m_section);
 613   for (std::vector<std::string>::iterator it = m_texturePaths.begin(); it != m_texturePaths.end(); ++it)
 614   {
 615     if (*it == texturePath)
 616     {
 617       m_texturePaths.erase(it);
 618       return;
 619     }
 620   }
 621 }
 622
 623 std::string CGUITextureManager::GetTexturePath(const std::string &textureName, bool directory /* = false */)
 624 {
 625   if (CURL::IsFullPath(textureName))
 626     return textureName;
 627   else
 628   { // texture doesn't include the full path, so check all fallbacks
 629     std::unique_lock<CCriticalSection> lock(m_section);
 630     for (const std::string& it : m_texturePaths)
 631     {
 632       std::string path = URIUtils::AddFileToFolder(it, "media", textureName);
 633       if (directory)
 634       {
 635         if (XFILE::CDirectory::Exists(path))
 636           return path;
 637       }
 638       else
 639       {
 640         if (XFILE::CFile::Exists(path))
 641           return path;
 642       }
 643     }
 644   }
 645
 646   CLog::Log(LOGDEBUG, "[Warning] CGUITextureManager::GetTexturePath: could not find texture '{}'",
 647             textureName);
 648   return "";
 649 }
 650
 651 std::vector<std::string> CGUITextureManager::GetBundledTexturesFromPath(
 652     const std::string& texturePath)
 653 {
 654   std::vector<std::string> items = m_TexBundle[0].GetTexturesFromPath(texturePath);
 655   if (items.empty())
 656     items = m_TexBundle[1].GetTexturesFromPath(texturePath);
 657   return items;
 658 }