xbmc/pictures/PictureThumbLoader.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 "PictureThumbLoader.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "Picture.h"
  14 #include "ServiceBroker.h"
  15 #include "TextureCache.h"
  16 #include "URL.h"
  17 #include "filesystem/Directory.h"
  18 #include "filesystem/MultiPathDirectory.h"
  19 #include "guilib/GUIComponent.h"
  20 #include "guilib/GUIWindowManager.h"
  21 #include "settings/AdvancedSettings.h"
  22 #include "settings/Settings.h"
  23 #include "settings/SettingsComponent.h"
  24 #include "utils/FileExtensionProvider.h"
  25 #include "utils/FileUtils.h"
  26 #include "utils/URIUtils.h"
  27 #include "video/VideoFileItemClassify.h"
  28 #include "video/VideoThumbLoader.h"
  29
  30 using namespace KODI::VIDEO;
  31 using namespace XFILE;
  32
  33 CPictureThumbLoader::CPictureThumbLoader() : CThumbLoader()
  34 {
  35   m_regenerateThumbs = false;
  36 }
  37
  38 CPictureThumbLoader::~CPictureThumbLoader()
  39 {
  40   StopThread();
  41 }
  42
  43 void CPictureThumbLoader::OnLoaderFinish()
  44 {
  45   if (m_regenerateThumbs)
  46   {
  47     CGUIMessage msg(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_REFRESH_THUMBS);
  48     CServiceBroker::GetGUI()->GetWindowManager().SendMessage(msg);
  49   }
  50   m_regenerateThumbs = false;
  51   CThumbLoader::OnLoaderFinish();
  52 }
  53
  54 bool CPictureThumbLoader::LoadItem(CFileItem* pItem)
  55 {
  56   bool result  = LoadItemCached(pItem);
  57        result |= LoadItemLookup(pItem);
  58
  59   return result;
  60 }
  61
  62 bool CPictureThumbLoader::LoadItemCached(CFileItem* pItem)
  63 {
  64   if (pItem->m_bIsShareOrDrive
  65   ||  pItem->IsParentFolder())
  66     return false;
  67
  68   if (pItem->HasArt("thumb") && m_regenerateThumbs)
  69   {
  70     CServiceBroker::GetTextureCache()->ClearCachedImage(pItem->GetArt("thumb"));
  71     if (m_textureDatabase->Open())
  72     {
  73       m_textureDatabase->ClearTextureForPath(pItem->GetPath(), "thumb");
  74       m_textureDatabase->Close();
  75     }
  76     pItem->SetArt("thumb", "");
  77   }
  78
  79   std::string thumb;
  80   if (pItem->IsPicture() && !pItem->IsZIP() && !pItem->IsRAR() && !pItem->IsCBZ() && !pItem->IsCBR() && !pItem->IsPlayList())
  81   { // load the thumb from the image file
  82     thumb = pItem->HasArt("thumb") ? pItem->GetArt("thumb") : CTextureUtils::GetWrappedThumbURL(pItem->GetPath());
  83   }
  84   else if (IsVideo(*pItem) && !pItem->IsZIP() && !pItem->IsRAR() && !pItem->IsCBZ() &&
  85            !pItem->IsCBR() && !pItem->IsPlayList())
  86   { // video
  87     CVideoThumbLoader loader;
  88     loader.LoadItem(pItem);
  89   }
  90   else if (!pItem->HasArt("thumb"))
  91   { // folder, zip, cbz, rar, cbr, playlist may have a previously cached image
  92     thumb = GetCachedImage(*pItem, "thumb");
  93   }
  94   if (!thumb.empty())
  95   {
  96     CServiceBroker::GetTextureCache()->BackgroundCacheImage(thumb);
  97     pItem->SetArt("thumb", thumb);
  98   }
  99   pItem->FillInDefaultIcon();
 100   return true;
 101 }
 102
 103 bool CPictureThumbLoader::LoadItemLookup(CFileItem* pItem)
 104 {
 105   return false;
 106 }
 107
 108 void CPictureThumbLoader::ProcessFoldersAndArchives(CFileItem *pItem)
 109 {
 110   if (pItem->HasArt("thumb"))
 111     return;
 112
 113   CTextureDatabase db;
 114   db.Open();
 115   if (pItem->IsCBR() || pItem->IsCBZ())
 116   {
 117     std::string strTBN(URIUtils::ReplaceExtension(pItem->GetPath(),".tbn"));
 118     if (CFileUtils::Exists(strTBN))
 119     {
 120       db.SetTextureForPath(pItem->GetPath(), "thumb", strTBN);
 121       CServiceBroker::GetTextureCache()->BackgroundCacheImage(strTBN);
 122       pItem->SetArt("thumb", strTBN);
 123       return;
 124     }
 125   }
 126   if ((pItem->m_bIsFolder || pItem->IsCBR() || pItem->IsCBZ()) && !pItem->m_bIsShareOrDrive
 127       && !pItem->IsParentFolder() && !pItem->IsPath("add"))
 128   {
 129     // first check for a folder.jpg
 130     std::string thumb = "folder.jpg";
 131     CURL pathToUrl = pItem->GetURL();
 132     if (pItem->IsCBR())
 133     {
 134       pathToUrl = URIUtils::CreateArchivePath("rar",pItem->GetURL(),"");
 135       thumb = "cover.jpg";
 136     }
 137     if (pItem->IsCBZ())
 138     {
 139       pathToUrl = URIUtils::CreateArchivePath("zip",pItem->GetURL(),"");
 140       thumb = "cover.jpg";
 141     }
 142     if (pItem->IsMultiPath())
 143       pathToUrl = CURL(CMultiPathDirectory::GetFirstPath(pItem->GetPath()));
 144     thumb = URIUtils::AddFileToFolder(pathToUrl.Get(), thumb);
 145     if (CFileUtils::Exists(thumb))
 146     {
 147       db.SetTextureForPath(pItem->GetPath(), "thumb", thumb);
 148       CServiceBroker::GetTextureCache()->BackgroundCacheImage(thumb);
 149       pItem->SetArt("thumb", thumb);
 150       return;
 151     }
 152     if (!pItem->IsPlugin())
 153     {
 154       // we load the directory, grab 4 random thumb files (if available) and then generate
 155       // the thumb.
 156
 157       CFileItemList items;
 158
 159       CDirectory::GetDirectory(pathToUrl, items, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS);
 160
 161       // create the folder thumb by choosing 4 random thumbs within the folder and putting
 162       // them into one thumb.
 163       // count the number of images
 164       for (int i=0; i < items.Size();)
 165       {
 166         if (!items[i]->IsPicture() || items[i]->IsZIP() || items[i]->IsRAR() || items[i]->IsPlayList())
 167         {
 168           items.Remove(i);
 169         }
 170         else
 171           i++;
 172       }
 173
 174       if (items.IsEmpty())
 175       {
 176         if (pItem->IsCBZ() || pItem->IsCBR())
 177         {
 178           CDirectory::GetDirectory(pathToUrl, items, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS);
 179           for (int i=0;i<items.Size();++i)
 180           {
 181             CFileItemPtr item = items[i];
 182             if (item->m_bIsFolder)
 183             {
 184               ProcessFoldersAndArchives(item.get());
 185               pItem->SetArt("thumb", items[i]->GetArt("thumb"));
 186               pItem->SetArt("icon", items[i]->GetArt("icon"));
 187               return;
 188             }
 189           }
 190         }
 191         return; // no images in this folder
 192       }
 193
 194       // randomize them
 195       items.Randomize();
 196
 197       if (items.Size() < 4 || pItem->IsCBR() || pItem->IsCBZ())
 198       { // less than 4 items, so just grab the first thumb
 199         items.Sort(SortByLabel, SortOrderAscending);
 200         std::string thumb = CTextureUtils::GetWrappedThumbURL(items[0]->GetPath());
 201         db.SetTextureForPath(pItem->GetPath(), "thumb", thumb);
 202         CServiceBroker::GetTextureCache()->BackgroundCacheImage(thumb);
 203         pItem->SetArt("thumb", thumb);
 204       }
 205       else
 206       {
 207         std::string thumb = CTextureUtils::GetWrappedImageURL(pItem->GetPath(), "picturefolder");
 208         db.SetTextureForPath(pItem->GetPath(), "thumb", thumb);
 209         pItem->SetArt("thumb", thumb);
 210       }
 211     }
 212     // refill in the icon to get it to update
 213     pItem->FillInDefaultIcon();
 214   }
 215 }