xbmc/music/MusicThumbLoader.cpp

   1 /*
   2  *  Copyright (C) 2012-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 "MusicThumbLoader.h"
  10
  11 #include "FileItem.h"
  12 #include "imagefiles/ImageFileURL.h"
  13 #include "music/infoscanner/MusicInfoScanner.h"
  14 #include "music/tags/MusicInfoTag.h"
  15 #include "utils/StringUtils.h"
  16 #include "video/VideoThumbLoader.h"
  17
  18 #include <utility>
  19
  20 using namespace MUSIC_INFO;
  21
  22 CMusicThumbLoader::CMusicThumbLoader() : CThumbLoader()
  23 {
  24   m_musicDatabase = new CMusicDatabase;
  25 }
  26
  27 CMusicThumbLoader::~CMusicThumbLoader()
  28 {
  29   delete m_musicDatabase;
  30 }
  31
  32 void CMusicThumbLoader::OnLoaderStart()
  33 {
  34   m_musicDatabase->Open();
  35   m_albumArt.clear();
  36   CThumbLoader::OnLoaderStart();
  37 }
  38
  39 void CMusicThumbLoader::OnLoaderFinish()
  40 {
  41   m_musicDatabase->Close();
  42   m_albumArt.clear();
  43   CThumbLoader::OnLoaderFinish();
  44 }
  45
  46 bool CMusicThumbLoader::LoadItem(CFileItem* pItem)
  47 {
  48   bool result  = LoadItemCached(pItem);
  49        result |= LoadItemLookup(pItem);
  50
  51   return result;
  52 }
  53
  54 bool CMusicThumbLoader::LoadItemCached(CFileItem* pItem)
  55 {
  56   if (pItem->m_bIsShareOrDrive)
  57     return false;
  58
  59   if (pItem->HasMusicInfoTag() && !pItem->GetProperty("libraryartfilled").asBoolean())
  60   {
  61     if (FillLibraryArt(*pItem))
  62       return true;
  63
  64     if (pItem->GetMusicInfoTag()->GetType() == MediaTypeArtist)
  65       return false; // No fallback
  66   }
  67
  68   if (pItem->HasVideoInfoTag() && !pItem->HasArt("thumb"))
  69   { // music video
  70     CVideoThumbLoader loader;
  71     if (loader.LoadItemCached(pItem))
  72       return true;
  73   }
  74
  75   // Fallback to folder thumb when path has one cached
  76   if (!pItem->HasArt("thumb"))
  77   {
  78     std::string art = GetCachedImage(*pItem, "thumb");
  79     if (!art.empty())
  80       pItem->SetArt("thumb", art);
  81   }
  82
  83   // Fallback to folder fanart when path has one cached
  84   //! @todo Remove as "fanart" is never been cached for music folders (only for
  85   // artists) or start caching fanart for folders?
  86   if (!pItem->HasArt("fanart"))
  87   {
  88     std::string art = GetCachedImage(*pItem, "fanart");
  89     if (!art.empty())
  90     {
  91       pItem->SetArt("fanart", art);
  92     }
  93   }
  94
  95   return false;
  96 }
  97
  98 bool CMusicThumbLoader::LoadItemLookup(CFileItem* pItem)
  99 {
 100   if (pItem->m_bIsShareOrDrive)
 101     return false;
 102
 103   if (pItem->HasMusicInfoTag() && pItem->GetMusicInfoTag()->GetType() == MediaTypeArtist) // No fallback for artist
 104     return false;
 105
 106   if (pItem->HasVideoInfoTag())
 107   { // music video
 108     CVideoThumbLoader loader;
 109     if (loader.LoadItemLookup(pItem))
 110       return true;
 111   }
 112
 113   if (!pItem->HasArt("thumb"))
 114   {
 115     // Look for embedded art
 116     if (pItem->HasMusicInfoTag() && !pItem->GetMusicInfoTag()->GetCoverArtInfo().Empty())
 117     {
 118       // The item has got embedded art but user thumbs overrule, so check for those first
 119       if (!FillThumb(*pItem, false)) // Check for user thumbs but ignore folder thumbs
 120       {
 121         // No user thumb, use embedded art
 122         std::string thumb = IMAGE_FILES::URLFromFile(pItem->GetPath(), "music");
 123         pItem->SetArt("thumb", thumb);
 124       }
 125     }
 126     else
 127     {
 128       // Check for user thumbs
 129       FillThumb(*pItem, true);
 130     }
 131   }
 132
 133   return true;
 134 }
 135
 136 bool CMusicThumbLoader::FillThumb(CFileItem &item, bool folderThumbs /* = true */)
 137 {
 138   if (item.HasArt("thumb"))
 139     return true;
 140   std::string thumb = GetCachedImage(item, "thumb");
 141   if (thumb.empty())
 142   {
 143     thumb = item.GetUserMusicThumb(false, folderThumbs);
 144     if (!thumb.empty())
 145       SetCachedImage(item, "thumb", thumb);
 146   }
 147   if (!thumb.empty())
 148     item.SetArt("thumb", thumb);
 149   return !thumb.empty();
 150 }
 151
 152 bool CMusicThumbLoader::FillLibraryArt(CFileItem &item)
 153 {
 154   /* Called for any item with MusicInfoTag and no art.
 155      Items on Genres, Sources and Roles nodes have ID (although items on Years
 156      node do not) so check for song/album/artist specifically.
 157      Non-library songs (file view) can also have MusicInfoTag but no ID or type
 158   */
 159   bool artfound(false);
 160   std::vector<ArtForThumbLoader> art;
 161   CMusicInfoTag &tag = *item.GetMusicInfoTag();
 162   if (tag.GetDatabaseId() > -1 &&
 163       (tag.GetType() == MediaTypeSong || tag.GetType() == MediaTypeAlbum ||
 164        tag.GetType() == MediaTypeArtist))
 165   {
 166     // Item in music library, fetch the art
 167     m_musicDatabase->Open();
 168     if (tag.GetType() == MediaTypeSong)
 169       artfound = m_musicDatabase->GetArtForItem(tag.GetDatabaseId(), tag.GetAlbumId(), -1, false, art);
 170     else if (tag.GetType() == MediaTypeAlbum)
 171       artfound = m_musicDatabase->GetArtForItem(-1, tag.GetDatabaseId(), -1, false, art);
 172     else //Artist
 173       artfound = m_musicDatabase->GetArtForItem(-1, -1, tag.GetDatabaseId(), true, art);
 174
 175     m_musicDatabase->Close();
 176   }
 177   else if (!tag.GetArtist().empty() &&
 178            (tag.GetType() == MediaTypeNone || tag.GetType() == MediaTypeSong))
 179   {
 180     /*
 181     Could be non-library song - has musictag but no ID or type (may have
 182     thumb already). Try to fetch both song artist(s) and album artist(s) art by
 183     artist name, e.g. "artist.thumb", "artist.fanart", "artist.clearlogo",
 184     "artist.banner", "artist1.thumb", "artist1.fanart", "artist1.clearlogo",
 185     "artist1.banner", "albumartist.thumb", "albumartist.fanart" etc.
 186     Set fanart as fallback.
 187     */
 188     CSong song;
 189     // Try to split song artist names (various tags) into artist credits
 190     song.SetArtistCredits(tag.GetArtist(), tag.GetMusicBrainzArtistHints(), tag.GetMusicBrainzArtistID());
 191     if (!song.artistCredits.empty())
 192     {
 193       tag.SetType(MediaTypeSong);  // Makes "Information" context menu visible
 194       m_musicDatabase->Open();
 195       int iOrder = 0;
 196       // Song artist art
 197       for (const auto& artistCredit : song.artistCredits)
 198       {
 199         int idArtist = m_musicDatabase->GetArtistByName(artistCredit.GetArtist());
 200         if (idArtist > 0)
 201         {
 202           std::vector<ArtForThumbLoader> artistart;
 203           if (m_musicDatabase->GetArtForItem(-1, -1, idArtist, true, artistart))
 204           {
 205             for (auto& artitem : artistart)
 206             {
 207               if (iOrder > 0)
 208                 artitem.prefix = StringUtils::Format("artist{}", iOrder);
 209               else
 210                 artitem.prefix = "artist";
 211             }
 212             art.insert(art.end(), artistart.begin(), artistart.end());
 213           }
 214         }
 215         ++iOrder;
 216       }
 217       // Album artist art
 218       if (!tag.GetAlbumArtist().empty() && tag.GetArtistString().compare(tag.GetAlbumArtistString()) != 0)
 219       {
 220         // Split song artist names correctly into artist credits from various tag
 221         // arrays, inc. fallback to song artist names
 222         CAlbum album;
 223         album.SetArtistCredits(tag.GetAlbumArtist(), tag.GetMusicBrainzAlbumArtistHints(), tag.GetMusicBrainzAlbumArtistID(),
 224           tag.GetArtist(), tag.GetMusicBrainzArtistHints(), tag.GetMusicBrainzArtistID());
 225
 226         iOrder = 0;
 227         for (const auto& artistCredit : album.artistCredits)
 228         {
 229           int idArtist = m_musicDatabase->GetArtistByName(artistCredit.GetArtist());
 230           if (idArtist > 0)
 231           {
 232             std::vector<ArtForThumbLoader> artistart;
 233             if (m_musicDatabase->GetArtForItem(-1, -1, idArtist, true, artistart))
 234             {
 235               for (auto& artitem : artistart)
 236               {
 237                 if (iOrder > 0)
 238                   artitem.prefix = StringUtils::Format("albumartist{}", iOrder);
 239                 else
 240                   artitem.prefix = "albumartist";
 241               }
 242               art.insert(art.end(), artistart.begin(), artistart.end());
 243             }
 244           }
 245           ++iOrder;
 246         }
 247       }
 248       else
 249       {
 250         // Replicate the artist art as album artist art
 251         std::vector<ArtForThumbLoader> artistart;
 252         for (const auto& artitem : art)
 253         {
 254           ArtForThumbLoader newart;
 255           newart.artType = artitem.artType;
 256           newart.mediaType = artitem.mediaType;
 257           newart.prefix = "album" + artitem.prefix;
 258           newart.url = artitem.url;
 259           artistart.emplace_back(newart);
 260         }
 261         art.insert(art.end(), artistart.begin(), artistart.end());
 262       }
 263       artfound = !art.empty();
 264       m_musicDatabase->Close();
 265     }
 266   }
 267
 268   if (artfound)
 269   {
 270     std::string fanartfallback;
 271     std::string artname;
 272     std::map<std::string, std::string> artmap;
 273     std::map<std::string, std::string> discartmap;
 274     for (auto artitem : art)
 275     {
 276       /* Add art to artmap, naming according to media type.
 277       For example: artists have "thumb", "fanart", "poster" etc.,
 278       albums have "thumb", "artist.thumb", "artist.fanart",... "artist1.thumb", "artist1.fanart" etc.,
 279       songs have "thumb", "album.thumb", "artist.thumb", "albumartist.thumb", "albumartist1.thumb" etc.
 280       */
 281       if (tag.GetType() == artitem.mediaType)
 282         artname = artitem.artType;
 283       else if (artitem.prefix.empty())
 284         artname = artitem.mediaType + "." + artitem.artType;
 285       else
 286       {
 287         if (tag.GetType() == MediaTypeAlbum)
 288           StringUtils::Replace(artitem.prefix, "albumartist", "artist");
 289         artname = artitem.prefix + "." + artitem.artType;
 290       }
 291
 292       // Pull out album art for this specific disc e.g. "thumb2", skip art for other discs
 293       if (artitem.mediaType == MediaTypeAlbum && tag.GetDiscNumber() > 0)
 294       {
 295         // Find any trailing digits
 296         size_t startnum = artitem.artType.find_last_not_of("0123456789");
 297         std::string digits = artitem.artType.substr(startnum + 1);
 298         int num = atoi(digits.c_str());
 299         if (num > 0 && startnum < artitem.artType.size())
 300         {
 301           if (num == tag.GetDiscNumber())
 302             discartmap.insert(std::make_pair(artitem.artType.substr(0, startnum + 1), artitem.url));
 303           continue;
 304         }
 305       }
 306
 307       artmap.insert(std::make_pair(artname, artitem.url));
 308
 309       // Add fallback art for "thumb" and "fanart" art types only
 310       // Set album thumb as the fallback used when song thumb is missing
 311       if (tag.GetType() == MediaTypeSong && artitem.mediaType == MediaTypeAlbum &&
 312           artitem.artType == "thumb")
 313       {
 314         item.SetArtFallback(artitem.artType, artname);
 315       }
 316
 317       // For albums and songs set fallback fanart from the artist.
 318       // For songs prefer primary song artist over primary albumartist fanart as fallback fanart
 319       if (artitem.prefix == "artist" && artitem.artType == "fanart")
 320         fanartfallback = artname;
 321       if (artitem.prefix == "albumartist" && artitem.artType == "fanart" && fanartfallback.empty())
 322         fanartfallback = artname;
 323     }
 324     if (!fanartfallback.empty())
 325       item.SetArtFallback("fanart", fanartfallback);
 326
 327     // Process specific disc art when we have some
 328     for (const auto& discart : discartmap)
 329     {
 330       std::map<std::string, std::string>::iterator it;
 331       if (tag.GetType() == MediaTypeAlbum)
 332       {
 333         // Insert or replace album art with specific disc art
 334         it = artmap.find(discart.first);
 335         if (it != artmap.end())
 336           it->second = discart.second;
 337         else
 338           artmap.insert(discart);
 339       }
 340       else if (tag.GetType() == MediaTypeSong)
 341       {
 342         // Use disc thumb rather than album as fallback for song thumb
 343         // (Fallback approach is used to fill missing thumbs).
 344         if (discart.first == "thumb")
 345         {
 346           it = artmap.find("album.thumb");
 347           if (it != artmap.end())
 348             // Replace "album.thumb" already set as fallback
 349             it->second = discart.second;
 350           else
 351           {
 352             // Insert thumb for album and set as fallback
 353             artmap.insert(std::make_pair("album.thumb", discart.second));
 354             item.SetArtFallback("thumb", "album.thumb");
 355           }
 356         }
 357         else
 358         {
 359           // Apply disc art as song art when not have that type (fallback does not apply).
 360           // Art of other types could been set via JSON, or in future read from metadata
 361           it = artmap.find(discart.first);
 362           if (it == artmap.end())
 363             artmap.insert(discart);
 364         }
 365       }
 366     }
 367
 368     item.AppendArt(artmap);
 369     item.SetProperty("libraryartfilled", true);
 370   }
 371
 372   return artfound;
 373 }