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