xbmc/FileItem.cpp

   1 /*
   2  *  Copyright (C) 2005-2020 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 "FileItem.h"
  10
  11 #include "CueDocument.h"
  12 #include "ServiceBroker.h"
  13 #include "URL.h"
  14 #include "Util.h"
  15 #include "events/IEvent.h"
  16 #include "filesystem/CurlFile.h"
  17 #include "filesystem/Directory.h"
  18 #include "filesystem/File.h"
  19 #include "filesystem/MultiPathDirectory.h"
  20 #include "filesystem/MusicDatabaseDirectory.h"
  21 #include "filesystem/StackDirectory.h"
  22 #include "filesystem/VideoDatabaseDirectory.h"
  23 #include "filesystem/VideoDatabaseDirectory/QueryParams.h"
  24 #include "games/GameUtils.h"
  25 #include "games/tags/GameInfoTag.h"
  26 #include "guilib/LocalizeStrings.h"
  27 #include "media/MediaLockState.h"
  28 #include "music/Album.h"
  29 #include "music/Artist.h"
  30 #include "music/MusicDatabase.h"
  31 #include "music/tags/MusicInfoTag.h"
  32 #include "music/tags/MusicInfoTagLoaderFactory.h"
  33 #include "pictures/PictureInfoTag.h"
  34 #include "playlists/PlayList.h"
  35 #include "playlists/PlayListFactory.h"
  36 #include "pvr/PVRManager.h"
  37 #include "pvr/channels/PVRChannel.h"
  38 #include "pvr/channels/PVRChannelGroupMember.h"
  39 #include "pvr/epg/EpgInfoTag.h"
  40 #include "pvr/epg/EpgSearchFilter.h"
  41 #include "pvr/guilib/PVRGUIActionsChannels.h"
  42 #include "pvr/guilib/PVRGUIActionsUtils.h"
  43 #include "pvr/recordings/PVRRecording.h"
  44 #include "pvr/timers/PVRTimerInfoTag.h"
  45 #include "settings/AdvancedSettings.h"
  46 #include "settings/SettingUtils.h"
  47 #include "settings/Settings.h"
  48 #include "settings/SettingsComponent.h"
  49 #include "settings/lib/Setting.h"
  50 #include "utils/Archive.h"
  51 #include "utils/Crc32.h"
  52 #include "utils/FileExtensionProvider.h"
  53 #include "utils/Mime.h"
  54 #include "utils/Random.h"
  55 #include "utils/RegExp.h"
  56 #include "utils/StringUtils.h"
  57 #include "utils/URIUtils.h"
  58 #include "utils/Variant.h"
  59 #include "utils/log.h"
  60 #include "video/Bookmark.h"
  61 #include "video/VideoDatabase.h"
  62 #include "video/VideoInfoTag.h"
  63
  64 #include <algorithm>
  65 #include <cstdlib>
  66 #include <memory>
  67 #include <mutex>
  68
  69 using namespace KODI;
  70 using namespace XFILE;
  71 using namespace PLAYLIST;
  72 using namespace MUSIC_INFO;
  73 using namespace PVR;
  74 using namespace GAME;
  75
  76 CFileItem::CFileItem(const CSong& song)
  77 {
  78   Initialize();
  79   SetFromSong(song);
  80 }
  81
  82 CFileItem::CFileItem(const CSong& song, const CMusicInfoTag& music)
  83 {
  84   Initialize();
  85   SetFromSong(song);
  86   *GetMusicInfoTag() = music;
  87 }
  88
  89 CFileItem::CFileItem(const CURL &url, const CAlbum& album)
  90 {
  91   Initialize();
  92
  93   m_strPath = url.Get();
  94   URIUtils::AddSlashAtEnd(m_strPath);
  95   SetFromAlbum(album);
  96 }
  97
  98 CFileItem::CFileItem(const std::string &path, const CAlbum& album)
  99 {
 100   Initialize();
 101
 102   m_strPath = path;
 103   URIUtils::AddSlashAtEnd(m_strPath);
 104   SetFromAlbum(album);
 105 }
 106
 107 CFileItem::CFileItem(const CMusicInfoTag& music)
 108 {
 109   Initialize();
 110   SetLabel(music.GetTitle());
 111   m_strPath = music.GetURL();
 112   m_bIsFolder = URIUtils::HasSlashAtEnd(m_strPath);
 113   *GetMusicInfoTag() = music;
 114   FillInDefaultIcon();
 115   FillInMimeType(false);
 116 }
 117
 118 CFileItem::CFileItem(const CVideoInfoTag& movie)
 119 {
 120   Initialize();
 121   SetFromVideoInfoTag(movie);
 122 }
 123
 124 namespace
 125 {
 126 std::string GetEpgTagTitle(const std::shared_ptr<const CPVREpgInfoTag>& epgTag)
 127 {
 128   if (CServiceBroker::GetPVRManager().IsParentalLocked(epgTag))
 129     return g_localizeStrings.Get(19266); // Parental locked
 130   else if (epgTag->Title().empty() &&
 131            !CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 132                CSettings::SETTING_EPG_HIDENOINFOAVAILABLE))
 133     return g_localizeStrings.Get(19055); // no information available
 134   else
 135     return epgTag->Title();
 136 }
 137 } // unnamed namespace
 138
 139 void CFileItem::FillMusicInfoTag(const std::shared_ptr<const CPVREpgInfoTag>& tag)
 140 {
 141   CMusicInfoTag* musictag = GetMusicInfoTag(); // create (!) the music tag.
 142
 143   if (tag)
 144   {
 145     musictag->SetTitle(GetEpgTagTitle(tag));
 146     musictag->SetGenre(tag->Genre());
 147     musictag->SetDuration(tag->GetDuration());
 148     musictag->SetURL(tag->Path());
 149   }
 150   else if (!CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(
 151                CSettings::SETTING_EPG_HIDENOINFOAVAILABLE))
 152   {
 153     musictag->SetTitle(g_localizeStrings.Get(19055)); // no information available
 154   }
 155
 156   musictag->SetLoaded(true);
 157 }
 158
 159 CFileItem::CFileItem(const std::shared_ptr<CPVREpgInfoTag>& tag)
 160 {
 161   Initialize();
 162
 163   m_bIsFolder = false;
 164   m_epgInfoTag = tag;
 165   m_strPath = tag->Path();
 166   m_bCanQueue = false;
 167   SetLabel(GetEpgTagTitle(tag));
 168   m_dateTime = tag->StartAsLocalTime();
 169
 170   if (!tag->IconPath().empty())
 171   {
 172     SetArt("icon", tag->IconPath());
 173   }
 174   else
 175   {
 176     const std::string iconPath = tag->ChannelIconPath();
 177     if (!iconPath.empty())
 178       SetArt("icon", iconPath);
 179     else if (tag->IsRadio())
 180       SetArt("icon", "DefaultMusicSongs.png");
 181     else
 182       SetArt("icon", "DefaultTVShows.png");
 183   }
 184
 185   // Speedup FillInDefaultIcon()
 186   SetProperty("icon_never_overlay", true);
 187
 188   if (tag->IsRadio() && !HasMusicInfoTag())
 189     FillMusicInfoTag(tag);
 190
 191   FillInMimeType(false);
 192 }
 193
 194 CFileItem::CFileItem(const std::shared_ptr<PVR::CPVREpgSearchFilter>& filter)
 195 {
 196   Initialize();
 197
 198   m_bIsFolder = true;
 199   m_epgSearchFilter = filter;
 200   m_strPath = filter->GetPath();
 201   m_bCanQueue = false;
 202   SetLabel(filter->GetTitle());
 203
 204   const CDateTime lastExec = filter->GetLastExecutedDateTime();
 205   if (lastExec.IsValid())
 206     m_dateTime.SetFromUTCDateTime(lastExec);
 207
 208   SetArt("icon", "DefaultPVRSearch.png");
 209
 210   // Speedup FillInDefaultIcon()
 211   SetProperty("icon_never_overlay", true);
 212
 213   FillInMimeType(false);
 214 }
 215
 216 CFileItem::CFileItem(const std::shared_ptr<CPVRChannelGroupMember>& channelGroupMember)
 217 {
 218   Initialize();
 219
 220   const std::shared_ptr<const CPVRChannel> channel = channelGroupMember->Channel();
 221
 222   m_pvrChannelGroupMemberInfoTag = channelGroupMember;
 223
 224   m_strPath = channelGroupMember->Path();
 225   m_bIsFolder = false;
 226   m_bCanQueue = false;
 227   SetLabel(channel->ChannelName());
 228
 229   if (!channel->IconPath().empty())
 230     SetArt("icon", channel->IconPath());
 231   else if (channel->IsRadio())
 232     SetArt("icon", "DefaultMusicSongs.png");
 233   else
 234     SetArt("icon", "DefaultTVShows.png");
 235
 236   SetProperty("channelid", channel->ChannelID());
 237   SetProperty("path", channelGroupMember->Path());
 238   SetArt("thumb", channel->IconPath());
 239
 240   // Speedup FillInDefaultIcon()
 241   SetProperty("icon_never_overlay", true);
 242
 243   if (channel->IsRadio() && !HasMusicInfoTag())
 244   {
 245     const std::shared_ptr<const CPVREpgInfoTag> epgNow = channel->GetEPGNow();
 246     FillMusicInfoTag(epgNow);
 247   }
 248   FillInMimeType(false);
 249 }
 250
 251 CFileItem::CFileItem(const std::shared_ptr<CPVRRecording>& record)
 252 {
 253   Initialize();
 254
 255   m_bIsFolder = false;
 256   m_pvrRecordingInfoTag = record;
 257   m_strPath = record->m_strFileNameAndPath;
 258   SetLabel(record->m_strTitle);
 259   m_dateTime = record->RecordingTimeAsLocalTime();
 260   m_dwSize = record->GetSizeInBytes();
 261   m_bCanQueue = true;
 262
 263   // Set art
 264   if (!record->IconPath().empty())
 265     SetArt("icon", record->IconPath());
 266   else
 267   {
 268     const std::shared_ptr<const CPVRChannel> channel = record->Channel();
 269     if (channel && !channel->IconPath().empty())
 270       SetArt("icon", channel->IconPath());
 271     else if (record->IsRadio())
 272       SetArt("icon", "DefaultMusicSongs.png");
 273     else
 274       SetArt("icon", "DefaultTVShows.png");
 275   }
 276
 277   if (!record->ThumbnailPath().empty())
 278     SetArt("thumb", record->ThumbnailPath());
 279
 280   if (!record->FanartPath().empty())
 281     SetArt("fanart", record->FanartPath());
 282
 283   // Speedup FillInDefaultIcon()
 284   SetProperty("icon_never_overlay", true);
 285
 286   FillInMimeType(false);
 287 }
 288
 289 CFileItem::CFileItem(const std::shared_ptr<CPVRTimerInfoTag>& timer)
 290 {
 291   Initialize();
 292
 293   m_bIsFolder = timer->IsTimerRule();
 294   m_pvrTimerInfoTag = timer;
 295   m_strPath = timer->Path();
 296   SetLabel(timer->Title());
 297   m_dateTime = timer->StartAsLocalTime();
 298   m_bCanQueue = false;
 299
 300   if (!timer->ChannelIcon().empty())
 301     SetArt("icon", timer->ChannelIcon());
 302   else if (timer->IsRadio())
 303     SetArt("icon", "DefaultMusicSongs.png");
 304   else
 305     SetArt("icon", "DefaultTVShows.png");
 306
 307   // Speedup FillInDefaultIcon()
 308   SetProperty("icon_never_overlay", true);
 309
 310   FillInMimeType(false);
 311 }
 312
 313 CFileItem::CFileItem(const CArtist& artist)
 314 {
 315   Initialize();
 316   SetLabel(artist.strArtist);
 317   m_strPath = artist.strArtist;
 318   m_bIsFolder = true;
 319   URIUtils::AddSlashAtEnd(m_strPath);
 320   GetMusicInfoTag()->SetArtist(artist);
 321   FillInMimeType(false);
 322 }
 323
 324 CFileItem::CFileItem(const CGenre& genre)
 325 {
 326   Initialize();
 327   SetLabel(genre.strGenre);
 328   m_strPath = genre.strGenre;
 329   m_bIsFolder = true;
 330   URIUtils::AddSlashAtEnd(m_strPath);
 331   GetMusicInfoTag()->SetGenre(genre.strGenre);
 332   FillInMimeType(false);
 333 }
 334
 335 CFileItem::CFileItem(const CFileItem& item)
 336   : CGUIListItem(item),
 337     m_musicInfoTag(NULL),
 338     m_videoInfoTag(NULL),
 339     m_pictureInfoTag(NULL),
 340     m_gameInfoTag(NULL)
 341 {
 342   *this = item;
 343 }
 344
 345 CFileItem::CFileItem(const CGUIListItem& item)
 346 {
 347   Initialize();
 348   // not particularly pretty, but it gets around the issue of Initialize() defaulting
 349   // parameters in the CGUIListItem base class.
 350   *static_cast<CGUIListItem*>(this) = item;
 351
 352   FillInMimeType(false);
 353 }
 354
 355 CFileItem::CFileItem(void)
 356 {
 357   Initialize();
 358 }
 359
 360 CFileItem::CFileItem(const std::string& strLabel)
 361 {
 362   Initialize();
 363   SetLabel(strLabel);
 364 }
 365
 366 CFileItem::CFileItem(const char* strLabel)
 367 {
 368   Initialize();
 369   SetLabel(std::string(strLabel));
 370 }
 371
 372 CFileItem::CFileItem(const CURL& path, bool bIsFolder)
 373 {
 374   Initialize();
 375   m_strPath = path.Get();
 376   m_bIsFolder = bIsFolder;
 377   if (m_bIsFolder && !m_strPath.empty() && !IsFileFolder())
 378     URIUtils::AddSlashAtEnd(m_strPath);
 379   FillInMimeType(false);
 380 }
 381
 382 CFileItem::CFileItem(const std::string& strPath, bool bIsFolder)
 383 {
 384   Initialize();
 385   m_strPath = strPath;
 386   m_bIsFolder = bIsFolder;
 387   if (m_bIsFolder && !m_strPath.empty() && !IsFileFolder())
 388     URIUtils::AddSlashAtEnd(m_strPath);
 389   FillInMimeType(false);
 390 }
 391
 392 CFileItem::CFileItem(const CMediaSource& share)
 393 {
 394   Initialize();
 395   m_bIsFolder = true;
 396   m_bIsShareOrDrive = true;
 397   m_strPath = share.strPath;
 398   if (!IsRSS()) // no slash at end for rss feeds
 399     URIUtils::AddSlashAtEnd(m_strPath);
 400   std::string label = share.strName;
 401   if (!share.strStatus.empty())
 402     label = StringUtils::Format("{} ({})", share.strName, share.strStatus);
 403   SetLabel(label);
 404   m_iLockMode = share.m_iLockMode;
 405   m_strLockCode = share.m_strLockCode;
 406   m_iHasLock = share.m_iHasLock;
 407   m_iBadPwdCount = share.m_iBadPwdCount;
 408   m_iDriveType = share.m_iDriveType;
 409   SetArt("thumb", share.m_strThumbnailImage);
 410   SetLabelPreformatted(true);
 411   if (IsDVD())
 412     GetVideoInfoTag()->m_strFileNameAndPath = share.strDiskUniqueId; // share.strDiskUniqueId contains disc unique id
 413   FillInMimeType(false);
 414 }
 415
 416 CFileItem::CFileItem(std::shared_ptr<const ADDON::IAddon> addonInfo) : m_addonInfo(std::move(addonInfo))
 417 {
 418   Initialize();
 419 }
 420
 421 CFileItem::CFileItem(const EventPtr& eventLogEntry)
 422 {
 423   Initialize();
 424
 425   m_eventLogEntry = eventLogEntry;
 426   SetLabel(eventLogEntry->GetLabel());
 427   m_dateTime = eventLogEntry->GetDateTime();
 428   if (!eventLogEntry->GetIcon().empty())
 429     SetArt("icon", eventLogEntry->GetIcon());
 430 }
 431
 432 CFileItem::~CFileItem(void)
 433 {
 434   delete m_musicInfoTag;
 435   delete m_videoInfoTag;
 436   delete m_pictureInfoTag;
 437   delete m_gameInfoTag;
 438
 439   m_musicInfoTag = NULL;
 440   m_videoInfoTag = NULL;
 441   m_pictureInfoTag = NULL;
 442   m_gameInfoTag = NULL;
 443 }
 444
 445 CFileItem& CFileItem::operator=(const CFileItem& item)
 446 {
 447   if (this == &item)
 448     return *this;
 449
 450   CGUIListItem::operator=(item);
 451   m_bLabelPreformatted=item.m_bLabelPreformatted;
 452   FreeMemory();
 453   m_strPath = item.m_strPath;
 454   m_strDynPath = item.m_strDynPath;
 455   m_bIsParentFolder = item.m_bIsParentFolder;
 456   m_iDriveType = item.m_iDriveType;
 457   m_bIsShareOrDrive = item.m_bIsShareOrDrive;
 458   m_dateTime = item.m_dateTime;
 459   m_dwSize = item.m_dwSize;
 460
 461   if (item.m_musicInfoTag)
 462   {
 463     if (m_musicInfoTag)
 464       *m_musicInfoTag = *item.m_musicInfoTag;
 465     else
 466       m_musicInfoTag = new MUSIC_INFO::CMusicInfoTag(*item.m_musicInfoTag);
 467   }
 468   else
 469   {
 470     delete m_musicInfoTag;
 471     m_musicInfoTag = NULL;
 472   }
 473
 474   if (item.m_videoInfoTag)
 475   {
 476     if (m_videoInfoTag)
 477       *m_videoInfoTag = *item.m_videoInfoTag;
 478     else
 479       m_videoInfoTag = new CVideoInfoTag(*item.m_videoInfoTag);
 480   }
 481   else
 482   {
 483     delete m_videoInfoTag;
 484     m_videoInfoTag = NULL;
 485   }
 486
 487   if (item.m_pictureInfoTag)
 488   {
 489     if (m_pictureInfoTag)
 490       *m_pictureInfoTag = *item.m_pictureInfoTag;
 491     else
 492       m_pictureInfoTag = new CPictureInfoTag(*item.m_pictureInfoTag);
 493   }
 494   else
 495   {
 496     delete m_pictureInfoTag;
 497     m_pictureInfoTag = NULL;
 498   }
 499
 500   if (item.m_gameInfoTag)
 501   {
 502     if (m_gameInfoTag)
 503       *m_gameInfoTag = *item.m_gameInfoTag;
 504     else
 505       m_gameInfoTag = new CGameInfoTag(*item.m_gameInfoTag);
 506   }
 507   else
 508   {
 509     delete m_gameInfoTag;
 510     m_gameInfoTag = NULL;
 511   }
 512
 513   m_epgInfoTag = item.m_epgInfoTag;
 514   m_epgSearchFilter = item.m_epgSearchFilter;
 515   m_pvrChannelGroupMemberInfoTag = item.m_pvrChannelGroupMemberInfoTag;
 516   m_pvrRecordingInfoTag = item.m_pvrRecordingInfoTag;
 517   m_pvrTimerInfoTag = item.m_pvrTimerInfoTag;
 518   m_addonInfo = item.m_addonInfo;
 519   m_eventLogEntry = item.m_eventLogEntry;
 520
 521   m_lStartOffset = item.m_lStartOffset;
 522   m_lStartPartNumber = item.m_lStartPartNumber;
 523   m_lEndOffset = item.m_lEndOffset;
 524   m_strDVDLabel = item.m_strDVDLabel;
 525   m_strTitle = item.m_strTitle;
 526   m_iprogramCount = item.m_iprogramCount;
 527   m_idepth = item.m_idepth;
 528   m_iLockMode = item.m_iLockMode;
 529   m_strLockCode = item.m_strLockCode;
 530   m_iHasLock = item.m_iHasLock;
 531   m_iBadPwdCount = item.m_iBadPwdCount;
 532   m_bCanQueue=item.m_bCanQueue;
 533   m_mimetype = item.m_mimetype;
 534   m_extrainfo = item.m_extrainfo;
 535   m_specialSort = item.m_specialSort;
 536   m_bIsAlbum = item.m_bIsAlbum;
 537   m_doContentLookup = item.m_doContentLookup;
 538   return *this;
 539 }
 540
 541 void CFileItem::Initialize()
 542 {
 543   m_musicInfoTag = NULL;
 544   m_videoInfoTag = NULL;
 545   m_pictureInfoTag = NULL;
 546   m_gameInfoTag = NULL;
 547   m_bLabelPreformatted = false;
 548   m_bIsAlbum = false;
 549   m_dwSize = 0;
 550   m_bIsParentFolder = false;
 551   m_bIsShareOrDrive = false;
 552   m_iDriveType = CMediaSource::SOURCE_TYPE_UNKNOWN;
 553   m_lStartOffset = 0;
 554   m_lStartPartNumber = 1;
 555   m_lEndOffset = 0;
 556   m_iprogramCount = 0;
 557   m_idepth = 1;
 558   m_iLockMode = LOCK_MODE_EVERYONE;
 559   m_iBadPwdCount = 0;
 560   m_iHasLock = LOCK_STATE_NO_LOCK;
 561   m_bCanQueue = true;
 562   m_specialSort = SortSpecialNone;
 563   m_doContentLookup = true;
 564 }
 565
 566 void CFileItem::Reset()
 567 {
 568   // CGUIListItem members...
 569   m_strLabel2.clear();
 570   SetLabel("");
 571   FreeIcons();
 572   m_overlayIcon = ICON_OVERLAY_NONE;
 573   m_bSelected = false;
 574   m_bIsFolder = false;
 575
 576   m_strDVDLabel.clear();
 577   m_strTitle.clear();
 578   m_strPath.clear();
 579   m_strDynPath.clear();
 580   m_dateTime.Reset();
 581   m_strLockCode.clear();
 582   m_mimetype.clear();
 583   delete m_musicInfoTag;
 584   m_musicInfoTag=NULL;
 585   delete m_videoInfoTag;
 586   m_videoInfoTag=NULL;
 587   m_epgInfoTag.reset();
 588   m_epgSearchFilter.reset();
 589   m_pvrChannelGroupMemberInfoTag.reset();
 590   m_pvrRecordingInfoTag.reset();
 591   m_pvrTimerInfoTag.reset();
 592   delete m_pictureInfoTag;
 593   m_pictureInfoTag=NULL;
 594   delete m_gameInfoTag;
 595   m_gameInfoTag = NULL;
 596   m_extrainfo.clear();
 597   ClearProperties();
 598   m_eventLogEntry.reset();
 599
 600   Initialize();
 601   SetInvalid();
 602 }
 603
 604 // do not archive dynamic path
 605 void CFileItem::Archive(CArchive& ar)
 606 {
 607   CGUIListItem::Archive(ar);
 608
 609   if (ar.IsStoring())
 610   {
 611     ar << m_bIsParentFolder;
 612     ar << m_bLabelPreformatted;
 613     ar << m_strPath;
 614     ar << m_bIsShareOrDrive;
 615     ar << m_iDriveType;
 616     ar << m_dateTime;
 617     ar << m_dwSize;
 618     ar << m_strDVDLabel;
 619     ar << m_strTitle;
 620     ar << m_iprogramCount;
 621     ar << m_idepth;
 622     ar << m_lStartOffset;
 623     ar << m_lStartPartNumber;
 624     ar << m_lEndOffset;
 625     ar << m_iLockMode;
 626     ar << m_strLockCode;
 627     ar << m_iBadPwdCount;
 628
 629     ar << m_bCanQueue;
 630     ar << m_mimetype;
 631     ar << m_extrainfo;
 632     ar << m_specialSort;
 633     ar << m_doContentLookup;
 634
 635     if (m_musicInfoTag)
 636     {
 637       ar << 1;
 638       ar << *m_musicInfoTag;
 639     }
 640     else
 641       ar << 0;
 642     if (m_videoInfoTag)
 643     {
 644       ar << 1;
 645       ar << *m_videoInfoTag;
 646     }
 647     else
 648       ar << 0;
 649     if (m_pictureInfoTag)
 650     {
 651       ar << 1;
 652       ar << *m_pictureInfoTag;
 653     }
 654     else
 655       ar << 0;
 656     if (m_gameInfoTag)
 657     {
 658       ar << 1;
 659       ar << *m_gameInfoTag;
 660     }
 661     else
 662       ar << 0;
 663   }
 664   else
 665   {
 666     ar >> m_bIsParentFolder;
 667     ar >> m_bLabelPreformatted;
 668     ar >> m_strPath;
 669     ar >> m_bIsShareOrDrive;
 670     ar >> m_iDriveType;
 671     ar >> m_dateTime;
 672     ar >> m_dwSize;
 673     ar >> m_strDVDLabel;
 674     ar >> m_strTitle;
 675     ar >> m_iprogramCount;
 676     ar >> m_idepth;
 677     ar >> m_lStartOffset;
 678     ar >> m_lStartPartNumber;
 679     ar >> m_lEndOffset;
 680     int temp;
 681     ar >> temp;
 682     m_iLockMode = (LockType)temp;
 683     ar >> m_strLockCode;
 684     ar >> m_iBadPwdCount;
 685
 686     ar >> m_bCanQueue;
 687     ar >> m_mimetype;
 688     ar >> m_extrainfo;
 689     ar >> temp;
 690     m_specialSort = (SortSpecial)temp;
 691     ar >> m_doContentLookup;
 692
 693     int iType;
 694     ar >> iType;
 695     if (iType == 1)
 696       ar >> *GetMusicInfoTag();
 697     ar >> iType;
 698     if (iType == 1)
 699       ar >> *GetVideoInfoTag();
 700     ar >> iType;
 701     if (iType == 1)
 702       ar >> *GetPictureInfoTag();
 703     ar >> iType;
 704     if (iType == 1)
 705       ar >> *GetGameInfoTag();
 706
 707     SetInvalid();
 708   }
 709 }
 710
 711 void CFileItem::Serialize(CVariant& value) const
 712 {
 713   //CGUIListItem::Serialize(value["CGUIListItem"]);
 714
 715   value["strPath"] = m_strPath;
 716   value["dateTime"] = (m_dateTime.IsValid()) ? m_dateTime.GetAsRFC1123DateTime() : "";
 717   value["lastmodified"] = m_dateTime.IsValid() ? m_dateTime.GetAsDBDateTime() : "";
 718   value["size"] = m_dwSize;
 719   value["DVDLabel"] = m_strDVDLabel;
 720   value["title"] = m_strTitle;
 721   value["mimetype"] = m_mimetype;
 722   value["extrainfo"] = m_extrainfo;
 723
 724   if (m_musicInfoTag)
 725     (*m_musicInfoTag).Serialize(value["musicInfoTag"]);
 726
 727   if (m_videoInfoTag)
 728     (*m_videoInfoTag).Serialize(value["videoInfoTag"]);
 729
 730   if (m_pictureInfoTag)
 731     (*m_pictureInfoTag).Serialize(value["pictureInfoTag"]);
 732
 733   if (m_gameInfoTag)
 734     (*m_gameInfoTag).Serialize(value["gameInfoTag"]);
 735
 736   if (!m_mapProperties.empty())
 737   {
 738     auto& customProperties = value["customproperties"];
 739     for (const auto& prop : m_mapProperties)
 740       customProperties[prop.first] = prop.second;
 741   }
 742 }
 743
 744 void CFileItem::ToSortable(SortItem &sortable, Field field) const
 745 {
 746   switch (field)
 747   {
 748     case FieldPath:
 749       sortable[FieldPath] = m_strPath;
 750       break;
 751     case FieldDate:
 752       sortable[FieldDate] = (m_dateTime.IsValid()) ? m_dateTime.GetAsDBDateTime() : "";
 753       break;
 754     case FieldSize:
 755       sortable[FieldSize] = m_dwSize;
 756       break;
 757     case FieldDriveType:
 758       sortable[FieldDriveType] = m_iDriveType;
 759       break;
 760     case FieldStartOffset:
 761       sortable[FieldStartOffset] = m_lStartOffset;
 762       break;
 763     case FieldEndOffset:
 764       sortable[FieldEndOffset] = m_lEndOffset;
 765       break;
 766     case FieldProgramCount:
 767       sortable[FieldProgramCount] = m_iprogramCount;
 768       break;
 769     case FieldBitrate:
 770       sortable[FieldBitrate] = m_dwSize;
 771       break;
 772     case FieldTitle:
 773       sortable[FieldTitle] = m_strTitle;
 774       break;
 775
 776     // If there's ever a need to convert more properties from CGUIListItem it might be
 777     // worth to make CGUIListItem implement ISortable as well and call it from here
 778
 779     default:
 780       break;
 781   }
 782
 783   if (HasMusicInfoTag())
 784     GetMusicInfoTag()->ToSortable(sortable, field);
 785
 786   if (HasVideoInfoTag())
 787     GetVideoInfoTag()->ToSortable(sortable, field);
 788
 789   if (HasPictureInfoTag())
 790     GetPictureInfoTag()->ToSortable(sortable, field);
 791
 792   if (HasPVRChannelInfoTag())
 793     GetPVRChannelInfoTag()->ToSortable(sortable, field);
 794
 795   if (HasPVRChannelGroupMemberInfoTag())
 796     GetPVRChannelGroupMemberInfoTag()->ToSortable(sortable, field);
 797
 798   if (HasAddonInfo())
 799   {
 800     switch (field)
 801     {
 802       case FieldInstallDate:
 803         sortable[FieldInstallDate] = GetAddonInfo()->InstallDate().GetAsDBDateTime();
 804         break;
 805       case FieldLastUpdated:
 806         sortable[FieldLastUpdated] = GetAddonInfo()->LastUpdated().GetAsDBDateTime();
 807         break;
 808       case FieldLastUsed:
 809         sortable[FieldLastUsed] = GetAddonInfo()->LastUsed().GetAsDBDateTime();
 810         break;
 811       default:
 812         break;
 813     }
 814   }
 815
 816   if (HasGameInfoTag())
 817     GetGameInfoTag()->ToSortable(sortable, field);
 818
 819   if (m_eventLogEntry)
 820     m_eventLogEntry->ToSortable(sortable, field);
 821
 822   if (IsFavourite())
 823   {
 824     if (field == FieldUserPreference)
 825       sortable[FieldUserPreference] = GetProperty("favourite.index").asString();
 826   }
 827 }
 828
 829 void CFileItem::ToSortable(SortItem &sortable, const Fields &fields) const
 830 {
 831   Fields::const_iterator it;
 832   for (it = fields.begin(); it != fields.end(); ++it)
 833     ToSortable(sortable, *it);
 834
 835   /* FieldLabel is used as a fallback by all sorters and therefore has to be present as well */
 836   sortable[FieldLabel] = GetLabel();
 837   /* FieldSortSpecial and FieldFolder are required in conjunction with all other sorters as well */
 838   sortable[FieldSortSpecial] = m_specialSort;
 839   sortable[FieldFolder] = m_bIsFolder;
 840 }
 841
 842 bool CFileItem::Exists(bool bUseCache /* = true */) const
 843 {
 844   if (m_strPath.empty()
 845    || IsPath("add")
 846    || IsInternetStream()
 847    || IsParentFolder()
 848    || IsVirtualDirectoryRoot()
 849    || IsPlugin()
 850    || IsPVR())
 851     return true;
 852
 853   if (IsVideoDb() && HasVideoInfoTag())
 854   {
 855     CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
 856     return dbItem.Exists();
 857   }
 858
 859   std::string strPath = m_strPath;
 860
 861   if (URIUtils::IsMultiPath(strPath))
 862     strPath = CMultiPathDirectory::GetFirstPath(strPath);
 863
 864   if (URIUtils::IsStack(strPath))
 865     strPath = CStackDirectory::GetFirstStackedFile(strPath);
 866
 867   if (m_bIsFolder)
 868     return CDirectory::Exists(strPath, bUseCache);
 869   else
 870     return CFile::Exists(strPath, bUseCache);
 871
 872   return false;
 873 }
 874
 875 bool CFileItem::IsVideo() const
 876 {
 877   /* check preset mime type */
 878   if(StringUtils::StartsWithNoCase(m_mimetype, "video/"))
 879     return true;
 880
 881   if (HasVideoInfoTag())
 882     return true;
 883
 884   if (HasGameInfoTag())
 885     return false;
 886
 887   if (HasMusicInfoTag())
 888     return false;
 889
 890   if (HasPictureInfoTag())
 891     return false;
 892
 893   // TV recordings are videos...
 894   if (!m_bIsFolder && URIUtils::IsPVRTVRecordingFileOrFolder(GetPath()))
 895     return true;
 896
 897   // ... all other PVR items are not.
 898   if (IsPVR())
 899     return false;
 900
 901   if (URIUtils::IsDVD(m_strPath))
 902     return true;
 903
 904   std::string extension;
 905   if(StringUtils::StartsWithNoCase(m_mimetype, "application/"))
 906   { /* check for some standard types */
 907     extension = m_mimetype.substr(12);
 908     if( StringUtils::EqualsNoCase(extension, "ogg")
 909      || StringUtils::EqualsNoCase(extension, "mp4")
 910      || StringUtils::EqualsNoCase(extension, "mxf") )
 911      return true;
 912   }
 913
 914   //! @todo If the file is a zip file, ask the game clients if any support this
 915   // file before assuming it is video.
 916
 917   return URIUtils::HasExtension(m_strPath, CServiceBroker::GetFileExtensionProvider().GetVideoExtensions());
 918 }
 919
 920 bool CFileItem::IsEPG() const
 921 {
 922   return HasEPGInfoTag();
 923 }
 924
 925 bool CFileItem::IsPVRChannel() const
 926 {
 927   return HasPVRChannelInfoTag();
 928 }
 929
 930 bool CFileItem::IsPVRChannelGroup() const
 931 {
 932   return URIUtils::IsPVRChannelGroup(m_strPath);
 933 }
 934
 935 bool CFileItem::IsPVRRecording() const
 936 {
 937   return HasPVRRecordingInfoTag();
 938 }
 939
 940 bool CFileItem::IsUsablePVRRecording() const
 941 {
 942   return (m_pvrRecordingInfoTag && !m_pvrRecordingInfoTag->IsDeleted());
 943 }
 944
 945 bool CFileItem::IsDeletedPVRRecording() const
 946 {
 947   return (m_pvrRecordingInfoTag && m_pvrRecordingInfoTag->IsDeleted());
 948 }
 949
 950 bool CFileItem::IsInProgressPVRRecording() const
 951 {
 952   return (m_pvrRecordingInfoTag && m_pvrRecordingInfoTag->IsInProgress());
 953 }
 954
 955 bool CFileItem::IsPVRTimer() const
 956 {
 957   return HasPVRTimerInfoTag();
 958 }
 959
 960 bool CFileItem::IsDiscStub() const
 961 {
 962   if (IsVideoDb() && HasVideoInfoTag())
 963   {
 964     CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
 965     return dbItem.IsDiscStub();
 966   }
 967
 968   return URIUtils::HasExtension(m_strPath, CServiceBroker::GetFileExtensionProvider().GetDiscStubExtensions());
 969 }
 970
 971 bool CFileItem::IsAudio() const
 972 {
 973   /* check preset mime type */
 974   if(StringUtils::StartsWithNoCase(m_mimetype, "audio/"))
 975     return true;
 976
 977   if (HasMusicInfoTag())
 978     return true;
 979
 980   if (HasVideoInfoTag())
 981     return false;
 982
 983   if (HasPictureInfoTag())
 984     return false;
 985
 986   if (HasGameInfoTag())
 987     return false;
 988
 989   if (IsCDDA())
 990     return true;
 991
 992   if(StringUtils::StartsWithNoCase(m_mimetype, "application/"))
 993   { /* check for some standard types */
 994     std::string extension = m_mimetype.substr(12);
 995     if( StringUtils::EqualsNoCase(extension, "ogg")
 996      || StringUtils::EqualsNoCase(extension, "mp4")
 997      || StringUtils::EqualsNoCase(extension, "mxf") )
 998      return true;
 999   }
1000
1001   //! @todo If the file is a zip file, ask the game clients if any support this
1002   // file before assuming it is audio
1003
1004   return URIUtils::HasExtension(m_strPath, CServiceBroker::GetFileExtensionProvider().GetMusicExtensions());
1005 }
1006
1007 bool CFileItem::IsDeleted() const
1008 {
1009   if (HasPVRRecordingInfoTag())
1010     return GetPVRRecordingInfoTag()->IsDeleted();
1011
1012   return false;
1013 }
1014
1015 bool CFileItem::IsAudioBook() const
1016 {
1017   return IsType(".m4b") || IsType(".mka");
1018 }
1019
1020 bool CFileItem::IsGame() const
1021 {
1022   if (HasGameInfoTag())
1023     return true;
1024
1025   if (HasVideoInfoTag())
1026     return false;
1027
1028   if (HasMusicInfoTag())
1029     return false;
1030
1031   if (HasPictureInfoTag())
1032     return false;
1033
1034   if (IsPVR())
1035     return false;
1036
1037   if (HasAddonInfo())
1038     return CGameUtils::IsStandaloneGame(std::const_pointer_cast<ADDON::IAddon>(GetAddonInfo()));
1039
1040   return CGameUtils::HasGameExtension(m_strPath);
1041 }
1042
1043 bool CFileItem::IsPicture() const
1044 {
1045   if (StringUtils::StartsWithNoCase(m_mimetype, "image/"))
1046     return true;
1047
1048   if (HasPictureInfoTag())
1049     return true;
1050
1051   if (HasGameInfoTag())
1052     return false;
1053
1054   if (HasMusicInfoTag())
1055     return false;
1056
1057   if (HasVideoInfoTag())
1058     return false;
1059
1060   if (HasPVRTimerInfoTag() || HasPVRChannelInfoTag() || HasPVRChannelGroupMemberInfoTag() ||
1061       HasPVRRecordingInfoTag() || HasEPGInfoTag() || HasEPGSearchFilter())
1062     return false;
1063
1064   if (!m_strPath.empty())
1065     return CUtil::IsPicture(m_strPath);
1066
1067   return false;
1068 }
1069
1070 bool CFileItem::IsLyrics() const
1071 {
1072   return URIUtils::HasExtension(m_strPath, ".cdg|.lrc");
1073 }
1074
1075 bool CFileItem::IsSubtitle() const
1076 {
1077   return URIUtils::HasExtension(m_strPath, CServiceBroker::GetFileExtensionProvider().GetSubtitleExtensions());
1078 }
1079
1080 bool CFileItem::IsCUESheet() const
1081 {
1082   return URIUtils::HasExtension(m_strPath, ".cue");
1083 }
1084
1085 bool CFileItem::IsInternetStream(const bool bStrictCheck /* = false */) const
1086 {
1087   if (HasProperty("IsHTTPDirectory"))
1088     return bStrictCheck;
1089
1090   if (!m_strDynPath.empty())
1091     return URIUtils::IsInternetStream(m_strDynPath, bStrictCheck);
1092
1093   return URIUtils::IsInternetStream(m_strPath, bStrictCheck);
1094 }
1095
1096 bool CFileItem::IsStreamedFilesystem() const
1097 {
1098   if (!m_strDynPath.empty())
1099     return URIUtils::IsStreamedFilesystem(m_strDynPath);
1100
1101   return URIUtils::IsStreamedFilesystem(m_strPath);
1102 }
1103
1104 bool CFileItem::IsFileFolder(EFileFolderType types) const
1105 {
1106   EFileFolderType always_type = EFILEFOLDER_TYPE_ALWAYS;
1107
1108   /* internet streams are not directly expanded */
1109   if(IsInternetStream())
1110     always_type = EFILEFOLDER_TYPE_ONCLICK;
1111
1112   // strm files are not browsable
1113   if (IsType(".strm") && (types & EFILEFOLDER_TYPE_ONBROWSE))
1114     return false;
1115
1116   if(types & always_type)
1117   {
1118     if(IsSmartPlayList()
1119     || (IsPlayList() && CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_playlistAsFolders)
1120     || IsAPK()
1121     || IsZIP()
1122     || IsRAR()
1123     || IsRSS()
1124     || IsAudioBook()
1125     || IsType(".ogg|.oga|.xbt")
1126 #if defined(TARGET_ANDROID)
1127     || IsType(".apk")
1128 #endif
1129     )
1130     return true;
1131   }
1132
1133   if (CServiceBroker::IsAddonInterfaceUp() &&
1134       IsType(CServiceBroker::GetFileExtensionProvider().GetFileFolderExtensions().c_str()) &&
1135       CServiceBroker::GetFileExtensionProvider().CanOperateExtension(m_strPath))
1136     return true;
1137
1138   if(types & EFILEFOLDER_TYPE_ONBROWSE)
1139   {
1140     if((IsPlayList() && !CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_playlistAsFolders)
1141     || IsDiscImage())
1142       return true;
1143   }
1144
1145   return false;
1146 }
1147
1148 bool CFileItem::IsSmartPlayList() const
1149 {
1150   if (HasProperty("library.smartplaylist") && GetProperty("library.smartplaylist").asBoolean())
1151     return true;
1152
1153   return URIUtils::HasExtension(m_strPath, ".xsp");
1154 }
1155
1156 bool CFileItem::IsLibraryFolder() const
1157 {
1158   if (HasProperty("library.filter") && GetProperty("library.filter").asBoolean())
1159     return true;
1160
1161   return URIUtils::IsLibraryFolder(m_strPath);
1162 }
1163
1164 bool CFileItem::IsPlayList() const
1165 {
1166   return CPlayListFactory::IsPlaylist(*this);
1167 }
1168
1169 bool CFileItem::IsPythonScript() const
1170 {
1171   return URIUtils::HasExtension(m_strPath, ".py");
1172 }
1173
1174 bool CFileItem::IsType(const char *ext) const
1175 {
1176   if (!m_strDynPath.empty())
1177     return URIUtils::HasExtension(m_strDynPath, ext);
1178
1179   return URIUtils::HasExtension(m_strPath, ext);
1180 }
1181
1182 bool CFileItem::IsNFO() const
1183 {
1184   return URIUtils::HasExtension(m_strPath, ".nfo");
1185 }
1186
1187 bool CFileItem::IsVideoExtras() const
1188 {
1189   return m_bIsFolder &&
1190          StringUtils::EqualsNoCase(URIUtils::GetFileOrFolderName(m_strPath), "extras");
1191 }
1192
1193 bool CFileItem::IsDiscImage() const
1194 {
1195   return URIUtils::IsDiscImage(GetDynPath());
1196 }
1197
1198 bool CFileItem::IsOpticalMediaFile() const
1199 {
1200   if (IsDVDFile(false, true))
1201     return true;
1202
1203   return IsBDFile();
1204 }
1205
1206 bool CFileItem::IsDVDFile(bool bVobs /*= true*/, bool bIfos /*= true*/) const
1207 {
1208   std::string strFileName = URIUtils::GetFileName(GetDynPath());
1209   if (bIfos)
1210   {
1211     if (StringUtils::EqualsNoCase(strFileName, "video_ts.ifo"))
1212       return true;
1213     if (StringUtils::StartsWithNoCase(strFileName, "vts_") && StringUtils::EndsWithNoCase(strFileName, "_0.ifo") && strFileName.length() == 12)
1214       return true;
1215   }
1216   if (bVobs)
1217   {
1218     if (StringUtils::EqualsNoCase(strFileName, "video_ts.vob"))
1219       return true;
1220     if (StringUtils::StartsWithNoCase(strFileName, "vts_") && StringUtils::EndsWithNoCase(strFileName, ".vob"))
1221       return true;
1222   }
1223
1224   return false;
1225 }
1226
1227 bool CFileItem::IsBDFile() const
1228 {
1229   std::string strFileName = URIUtils::GetFileName(GetDynPath());
1230   return (StringUtils::EqualsNoCase(strFileName, "index.bdmv") || StringUtils::EqualsNoCase(strFileName, "MovieObject.bdmv")
1231           || StringUtils::EqualsNoCase(strFileName, "INDEX.BDM") || StringUtils::EqualsNoCase(strFileName, "MOVIEOBJ.BDM"));
1232 }
1233
1234 bool CFileItem::IsRAR() const
1235 {
1236   return URIUtils::IsRAR(m_strPath);
1237 }
1238
1239 bool CFileItem::IsAPK() const
1240 {
1241   return URIUtils::IsAPK(m_strPath);
1242 }
1243
1244 bool CFileItem::IsZIP() const
1245 {
1246   return URIUtils::IsZIP(m_strPath);
1247 }
1248
1249 bool CFileItem::IsCBZ() const
1250 {
1251   return URIUtils::HasExtension(m_strPath, ".cbz");
1252 }
1253
1254 bool CFileItem::IsCBR() const
1255 {
1256   return URIUtils::HasExtension(m_strPath, ".cbr");
1257 }
1258
1259 bool CFileItem::IsRSS() const
1260 {
1261   return StringUtils::StartsWithNoCase(m_strPath, "rss://") || URIUtils::HasExtension(m_strPath, ".rss")
1262       || StringUtils::StartsWithNoCase(m_strPath, "rsss://")
1263       || m_mimetype == "application/rss+xml";
1264 }
1265
1266 bool CFileItem::IsAndroidApp() const
1267 {
1268   return URIUtils::IsAndroidApp(m_strPath);
1269 }
1270
1271 bool CFileItem::IsStack() const
1272 {
1273   return URIUtils::IsStack(m_strPath);
1274 }
1275
1276 bool CFileItem::IsFavourite() const
1277 {
1278   return URIUtils::IsFavourite(m_strPath);
1279 }
1280
1281 bool CFileItem::IsPlugin() const
1282 {
1283   return URIUtils::IsPlugin(m_strPath);
1284 }
1285
1286 bool CFileItem::IsScript() const
1287 {
1288   return URIUtils::IsScript(m_strPath);
1289 }
1290
1291 bool CFileItem::IsAddonsPath() const
1292 {
1293   return URIUtils::IsAddonsPath(m_strPath);
1294 }
1295
1296 bool CFileItem::IsSourcesPath() const
1297 {
1298   return URIUtils::IsSourcesPath(m_strPath);
1299 }
1300
1301 bool CFileItem::IsMultiPath() const
1302 {
1303   return URIUtils::IsMultiPath(m_strPath);
1304 }
1305
1306 bool CFileItem::IsBluray() const
1307 {
1308   if (URIUtils::IsBluray(m_strPath))
1309     return true;
1310
1311   CFileItem item = CFileItem(GetOpticalMediaPath(), false);
1312
1313   return item.IsBDFile();
1314 }
1315
1316 bool CFileItem::IsProtectedBlurayDisc() const
1317 {
1318   std::string path;
1319   path = URIUtils::AddFileToFolder(GetPath(), "AACS", "Unit_Key_RO.inf");
1320   if (CFile::Exists(path))
1321     return true;
1322
1323   return false;
1324 }
1325
1326 bool CFileItem::IsCDDA() const
1327 {
1328   return URIUtils::IsCDDA(m_strPath);
1329 }
1330
1331 bool CFileItem::IsDVD() const
1332 {
1333   return URIUtils::IsDVD(m_strPath) || m_iDriveType == CMediaSource::SOURCE_TYPE_DVD;
1334 }
1335
1336 bool CFileItem::IsOnDVD() const
1337 {
1338   return URIUtils::IsOnDVD(m_strPath) || m_iDriveType == CMediaSource::SOURCE_TYPE_DVD;
1339 }
1340
1341 bool CFileItem::IsNfs() const
1342 {
1343   return URIUtils::IsNfs(m_strPath);
1344 }
1345
1346 bool CFileItem::IsOnLAN() const
1347 {
1348   return URIUtils::IsOnLAN(m_strPath);
1349 }
1350
1351 bool CFileItem::IsISO9660() const
1352 {
1353   return URIUtils::IsISO9660(m_strPath);
1354 }
1355
1356 bool CFileItem::IsRemote() const
1357 {
1358   return URIUtils::IsRemote(m_strPath);
1359 }
1360
1361 bool CFileItem::IsSmb() const
1362 {
1363   return URIUtils::IsSmb(m_strPath);
1364 }
1365
1366 bool CFileItem::IsURL() const
1367 {
1368   return URIUtils::IsURL(m_strPath);
1369 }
1370
1371 bool CFileItem::IsPVR() const
1372 {
1373   return URIUtils::IsPVR(m_strPath);
1374 }
1375
1376 bool CFileItem::IsLiveTV() const
1377 {
1378   return URIUtils::IsLiveTV(m_strPath);
1379 }
1380
1381 bool CFileItem::IsHD() const
1382 {
1383   return URIUtils::IsHD(m_strPath);
1384 }
1385
1386 bool CFileItem::IsMusicDb() const
1387 {
1388   return URIUtils::IsMusicDb(m_strPath);
1389 }
1390
1391 bool CFileItem::IsVideoDb() const
1392 {
1393   return URIUtils::IsVideoDb(m_strPath);
1394 }
1395
1396 bool CFileItem::IsVirtualDirectoryRoot() const
1397 {
1398   return (m_bIsFolder && m_strPath.empty());
1399 }
1400
1401 bool CFileItem::IsRemovable() const
1402 {
1403   return IsOnDVD() || IsCDDA() || m_iDriveType == CMediaSource::SOURCE_TYPE_REMOVABLE;
1404 }
1405
1406 bool CFileItem::IsReadOnly() const
1407 {
1408   if (IsParentFolder())
1409     return true;
1410
1411   if (m_bIsShareOrDrive)
1412     return true;
1413
1414   return !CUtil::SupportsWriteFileOperations(m_strPath);
1415 }
1416
1417 void CFileItem::FillInDefaultIcon()
1418 {
1419   if (URIUtils::IsPVRGuideItem(m_strPath))
1420   {
1421     // epg items never have a default icon. no need to execute this expensive method.
1422     // when filling epg grid window, easily tens of thousands of epg items are processed.
1423     return;
1424   }
1425
1426   //CLog::Log(LOGINFO, "FillInDefaultIcon({})", pItem->GetLabel());
1427   // find the default icon for a file or folder item
1428   // for files this can be the (depending on the file type)
1429   //   default picture for photo's
1430   //   default picture for songs
1431   //   default picture for videos
1432   //   default picture for shortcuts
1433   //   default picture for playlists
1434   //
1435   // for folders
1436   //   for .. folders the default picture for parent folder
1437   //   for other folders the defaultFolder.png
1438
1439   if (GetArt("icon").empty())
1440   {
1441     if (!m_bIsFolder)
1442     {
1443       /* To reduce the average runtime of this code, this list should
1444        * be ordered with most frequently seen types first.  Also bear
1445        * in mind the complexity of the code behind the check in the
1446        * case of IsWhatever() returns false.
1447        */
1448       if (IsPVRChannel())
1449       {
1450         if (GetPVRChannelInfoTag()->IsRadio())
1451           SetArt("icon", "DefaultMusicSongs.png");
1452         else
1453           SetArt("icon", "DefaultTVShows.png");
1454       }
1455       else if ( IsLiveTV() )
1456       {
1457         // Live TV Channel
1458         SetArt("icon", "DefaultTVShows.png");
1459       }
1460       else if ( URIUtils::IsArchive(m_strPath) )
1461       { // archive
1462         SetArt("icon", "DefaultFile.png");
1463       }
1464       else if ( IsUsablePVRRecording() )
1465       {
1466         // PVR recording
1467         SetArt("icon", "DefaultVideo.png");
1468       }
1469       else if ( IsDeletedPVRRecording() )
1470       {
1471         // PVR deleted recording
1472         SetArt("icon", "DefaultVideoDeleted.png");
1473       }
1474       else if ( IsAudio() )
1475       {
1476         // audio
1477         SetArt("icon", "DefaultAudio.png");
1478       }
1479       else if ( IsVideo() )
1480       {
1481         // video
1482         SetArt("icon", "DefaultVideo.png");
1483       }
1484       else if (IsPVRTimer())
1485       {
1486         SetArt("icon", "DefaultVideo.png");
1487       }
1488       else if ( IsPicture() )
1489       {
1490         // picture
1491         SetArt("icon", "DefaultPicture.png");
1492       }
1493       else if ( IsPlayList() || IsSmartPlayList())
1494       {
1495         SetArt("icon", "DefaultPlaylist.png");
1496       }
1497       else if ( IsPythonScript() )
1498       {
1499         SetArt("icon", "DefaultScript.png");
1500       }
1501       else if (IsFavourite())
1502       {
1503         SetArt("icon", "DefaultFavourites.png");
1504       }
1505       else
1506       {
1507         // default icon for unknown file type
1508         SetArt("icon", "DefaultFile.png");
1509       }
1510     }
1511     else
1512     {
1513       if ( IsPlayList() || IsSmartPlayList())
1514       {
1515         SetArt("icon", "DefaultPlaylist.png");
1516       }
1517       else if (IsParentFolder())
1518       {
1519         SetArt("icon", "DefaultFolderBack.png");
1520       }
1521       else
1522       {
1523         SetArt("icon", "DefaultFolder.png");
1524       }
1525     }
1526   }
1527   // Set the icon overlays (if applicable)
1528   if (!HasOverlay() && !HasProperty("icon_never_overlay"))
1529   {
1530     if (URIUtils::IsInRAR(m_strPath))
1531       SetOverlayImage(CGUIListItem::ICON_OVERLAY_RAR);
1532     else if (URIUtils::IsInZIP(m_strPath))
1533       SetOverlayImage(CGUIListItem::ICON_OVERLAY_ZIP);
1534   }
1535 }
1536
1537 void CFileItem::RemoveExtension()
1538 {
1539   if (m_bIsFolder)
1540     return;
1541
1542   std::string strLabel = GetLabel();
1543   URIUtils::RemoveExtension(strLabel);
1544   SetLabel(strLabel);
1545 }
1546
1547 void CFileItem::CleanString()
1548 {
1549   if (IsLiveTV())
1550     return;
1551
1552   std::string strLabel = GetLabel();
1553   std::string strTitle, strTitleAndYear, strYear;
1554   CUtil::CleanString(strLabel, strTitle, strTitleAndYear, strYear, true);
1555   SetLabel(strTitleAndYear);
1556 }
1557
1558 void CFileItem::SetLabel(const std::string &strLabel)
1559 {
1560   if (strLabel == "..")
1561   {
1562     m_bIsParentFolder = true;
1563     m_bIsFolder = true;
1564     m_specialSort = SortSpecialOnTop;
1565     SetLabelPreformatted(true);
1566   }
1567   CGUIListItem::SetLabel(strLabel);
1568 }
1569
1570 void CFileItem::SetFileSizeLabel()
1571 {
1572   if(m_bIsFolder && m_dwSize == 0)
1573     SetLabel2("");
1574   else
1575     SetLabel2(StringUtils::SizeToString(m_dwSize));
1576 }
1577
1578 bool CFileItem::CanQueue() const
1579 {
1580   return m_bCanQueue;
1581 }
1582
1583 void CFileItem::SetCanQueue(bool bYesNo)
1584 {
1585   m_bCanQueue = bYesNo;
1586 }
1587
1588 bool CFileItem::IsParentFolder() const
1589 {
1590   return m_bIsParentFolder;
1591 }
1592
1593 void CFileItem::FillInMimeType(bool lookup /*= true*/)
1594 {
1595   //! @todo adapt this to use CMime::GetMimeType()
1596   if (m_mimetype.empty())
1597   {
1598     if (m_bIsFolder)
1599       m_mimetype = "x-directory/normal";
1600     else if (HasPVRChannelInfoTag())
1601       m_mimetype = GetPVRChannelInfoTag()->MimeType();
1602     else if (StringUtils::StartsWithNoCase(GetDynPath(), "shout://") ||
1603              StringUtils::StartsWithNoCase(GetDynPath(), "http://") ||
1604              StringUtils::StartsWithNoCase(GetDynPath(), "https://"))
1605     {
1606       // If lookup is false, bail out early to leave mime type empty
1607       if (!lookup)
1608         return;
1609
1610       CCurlFile::GetMimeType(GetDynURL(), m_mimetype);
1611
1612       // try to get mime-type again but with an NSPlayer User-Agent
1613       // in order for server to provide correct mime-type.  Allows us
1614       // to properly detect an MMS stream
1615       if (StringUtils::StartsWithNoCase(m_mimetype, "video/x-ms-"))
1616         CCurlFile::GetMimeType(GetDynURL(), m_mimetype, "NSPlayer/11.00.6001.7000");
1617
1618       // make sure there are no options set in mime-type
1619       // mime-type can look like "video/x-ms-asf ; charset=utf8"
1620       size_t i = m_mimetype.find(';');
1621       if(i != std::string::npos)
1622         m_mimetype.erase(i, m_mimetype.length() - i);
1623       StringUtils::Trim(m_mimetype);
1624     }
1625     else
1626       m_mimetype = CMime::GetMimeType(*this);
1627
1628     // if it's still empty set to an unknown type
1629     if (m_mimetype.empty())
1630       m_mimetype = "application/octet-stream";
1631   }
1632
1633   // change protocol to mms for the following mime-type.  Allows us to create proper FileMMS.
1634   if(StringUtils::StartsWithNoCase(m_mimetype, "application/vnd.ms.wms-hdr.asfv1") ||
1635      StringUtils::StartsWithNoCase(m_mimetype, "application/x-mms-framed"))
1636   {
1637     if (m_strDynPath.empty())
1638       m_strDynPath = m_strPath;
1639
1640     StringUtils::Replace(m_strDynPath, "http:", "mms:");
1641   }
1642 }
1643
1644 void CFileItem::UpdateMimeType(bool lookup /*= true*/)
1645 {
1646   //! @todo application/octet-stream might actually have been set by a web lookup. Currently we
1647   //! cannot distinguish between set as fallback only (see FillInMimeType) or as an actual value.
1648   if (m_mimetype == "application/octet-stream")
1649     m_mimetype.clear();
1650
1651   FillInMimeType(lookup);
1652 }
1653
1654 void CFileItem::SetMimeTypeForInternetFile()
1655 {
1656   if (m_doContentLookup && IsInternetStream())
1657   {
1658     SetMimeType("");
1659     FillInMimeType(true);
1660   }
1661 }
1662
1663 bool CFileItem::IsSamePath(const CFileItem *item) const
1664 {
1665   if (!item)
1666     return false;
1667
1668   if (!m_strPath.empty() && item->GetPath() == m_strPath)
1669   {
1670     if (item->HasProperty("item_start") || HasProperty("item_start"))
1671       return (item->GetProperty("item_start") == GetProperty("item_start"));
1672     return true;
1673   }
1674   if (HasMusicInfoTag() && item->HasMusicInfoTag())
1675   {
1676     if (GetMusicInfoTag()->GetDatabaseId() != -1 && item->GetMusicInfoTag()->GetDatabaseId() != -1)
1677       return ((GetMusicInfoTag()->GetDatabaseId() == item->GetMusicInfoTag()->GetDatabaseId()) &&
1678         (GetMusicInfoTag()->GetType() == item->GetMusicInfoTag()->GetType()));
1679   }
1680   if (HasVideoInfoTag() && item->HasVideoInfoTag())
1681   {
1682     const CVideoInfoTag* myTag{GetVideoInfoTag()};
1683     const CVideoInfoTag* otherTag{item->GetVideoInfoTag()};
1684     if (myTag->m_iDbId != -1 && otherTag->m_iDbId != -1)
1685     {
1686       if ((myTag->m_iDbId == otherTag->m_iDbId) && (myTag->m_type == otherTag->m_type))
1687       {
1688         // for movies with multiple versions, wie need also to check the file id
1689         if (HasVideoVersions() && item->HasVideoVersions() && myTag->m_iFileId != -1 &&
1690             otherTag->m_iFileId != -1)
1691           return myTag->m_iFileId == otherTag->m_iFileId;
1692         return true;
1693       }
1694     }
1695   }
1696   if (IsMusicDb() && HasMusicInfoTag())
1697   {
1698     CFileItem dbItem(m_musicInfoTag->GetURL(), false);
1699     if (HasProperty("item_start"))
1700       dbItem.SetProperty("item_start", GetProperty("item_start"));
1701     return dbItem.IsSamePath(item);
1702   }
1703   if (IsVideoDb() && HasVideoInfoTag())
1704   {
1705     CFileItem dbItem(GetVideoInfoTag()->m_strFileNameAndPath, false);
1706     if (HasProperty("item_start"))
1707       dbItem.SetProperty("item_start", GetProperty("item_start"));
1708     return dbItem.IsSamePath(item);
1709   }
1710   if (item->IsMusicDb() && item->HasMusicInfoTag())
1711   {
1712     CFileItem dbItem(item->m_musicInfoTag->GetURL(), false);
1713     if (item->HasProperty("item_start"))
1714       dbItem.SetProperty("item_start", item->GetProperty("item_start"));
1715     return IsSamePath(&dbItem);
1716   }
1717   if (item->IsVideoDb() && item->HasVideoInfoTag())
1718   {
1719     CFileItem dbItem(item->GetVideoInfoTag()->m_strFileNameAndPath, false);
1720     if (item->HasProperty("item_start"))
1721       dbItem.SetProperty("item_start", item->GetProperty("item_start"));
1722     return IsSamePath(&dbItem);
1723   }
1724   if (HasProperty("original_listitem_url"))
1725     return (GetProperty("original_listitem_url") == item->GetPath());
1726   return false;
1727 }
1728
1729 bool CFileItem::IsAlbum() const
1730 {
1731   return m_bIsAlbum;
1732 }
1733
1734 void CFileItem::UpdateInfo(const CFileItem &item, bool replaceLabels /*=true*/)
1735 {
1736   if (item.HasVideoInfoTag())
1737   { // copy info across
1738     //! @todo premiered info is normally stored in m_dateTime by the db
1739
1740     if (item.m_videoInfoTag)
1741     {
1742       if (m_videoInfoTag)
1743         *m_videoInfoTag = *item.m_videoInfoTag;
1744       else
1745         m_videoInfoTag = new CVideoInfoTag(*item.m_videoInfoTag);
1746     }
1747     else
1748     {
1749       if (m_videoInfoTag)
1750         delete m_videoInfoTag;
1751
1752       m_videoInfoTag = new CVideoInfoTag;
1753     }
1754
1755     m_pvrRecordingInfoTag = item.m_pvrRecordingInfoTag;
1756
1757     SetOverlayImage(GetVideoInfoTag()->GetPlayCount() > 0 ? CGUIListItem::ICON_OVERLAY_WATCHED
1758                                                           : CGUIListItem::ICON_OVERLAY_UNWATCHED);
1759     SetInvalid();
1760   }
1761   if (item.HasMusicInfoTag())
1762   {
1763     *GetMusicInfoTag() = *item.GetMusicInfoTag();
1764     SetInvalid();
1765   }
1766   if (item.HasPictureInfoTag())
1767   {
1768     *GetPictureInfoTag() = *item.GetPictureInfoTag();
1769     SetInvalid();
1770   }
1771   if (item.HasGameInfoTag())
1772   {
1773     *GetGameInfoTag() = *item.GetGameInfoTag();
1774     SetInvalid();
1775   }
1776   if (item.HasPVRChannelGroupMemberInfoTag())
1777   {
1778     m_pvrChannelGroupMemberInfoTag = item.GetPVRChannelGroupMemberInfoTag();
1779     SetInvalid();
1780   }
1781   if (item.HasPVRTimerInfoTag())
1782   {
1783     m_pvrTimerInfoTag = item.m_pvrTimerInfoTag;
1784     SetInvalid();
1785   }
1786   if (item.HasEPGInfoTag())
1787   {
1788     m_epgInfoTag = item.m_epgInfoTag;
1789     SetInvalid();
1790   }
1791   if (item.HasEPGSearchFilter())
1792   {
1793     m_epgSearchFilter = item.m_epgSearchFilter;
1794     SetInvalid();
1795   }
1796   SetDynPath(item.GetDynPath());
1797   if (replaceLabels && !item.GetLabel().empty())
1798     SetLabel(item.GetLabel());
1799   if (replaceLabels && !item.GetLabel2().empty())
1800     SetLabel2(item.GetLabel2());
1801   if (!item.GetArt().empty())
1802     SetArt(item.GetArt());
1803   AppendProperties(item);
1804   UpdateMimeType();
1805 }
1806
1807 void CFileItem::MergeInfo(const CFileItem& item)
1808 {
1809   // TODO: Currently merge the metadata/art info is implemented for video case only
1810   if (item.HasVideoInfoTag())
1811   {
1812     if (item.m_videoInfoTag)
1813     {
1814       if (m_videoInfoTag)
1815         m_videoInfoTag->Merge(*item.m_videoInfoTag);
1816       else
1817         m_videoInfoTag = new CVideoInfoTag(*item.m_videoInfoTag);
1818     }
1819
1820     m_pvrRecordingInfoTag = item.m_pvrRecordingInfoTag;
1821
1822     SetOverlayImage(GetVideoInfoTag()->GetPlayCount() > 0 ? CGUIListItem::ICON_OVERLAY_WATCHED
1823                                                           : CGUIListItem::ICON_OVERLAY_UNWATCHED);
1824     SetInvalid();
1825   }
1826   if (item.HasMusicInfoTag())
1827   {
1828     *GetMusicInfoTag() = *item.GetMusicInfoTag();
1829     SetInvalid();
1830   }
1831   if (item.HasPictureInfoTag())
1832   {
1833     *GetPictureInfoTag() = *item.GetPictureInfoTag();
1834     SetInvalid();
1835   }
1836   if (item.HasGameInfoTag())
1837   {
1838     *GetGameInfoTag() = *item.GetGameInfoTag();
1839     SetInvalid();
1840   }
1841   if (item.HasPVRChannelGroupMemberInfoTag())
1842   {
1843     m_pvrChannelGroupMemberInfoTag = item.GetPVRChannelGroupMemberInfoTag();
1844     SetInvalid();
1845   }
1846   if (item.HasPVRTimerInfoTag())
1847   {
1848     m_pvrTimerInfoTag = item.m_pvrTimerInfoTag;
1849     SetInvalid();
1850   }
1851   if (item.HasEPGInfoTag())
1852   {
1853     m_epgInfoTag = item.m_epgInfoTag;
1854     SetInvalid();
1855   }
1856   if (item.HasEPGSearchFilter())
1857   {
1858     m_epgSearchFilter = item.m_epgSearchFilter;
1859     SetInvalid();
1860   }
1861   SetDynPath(item.GetDynPath());
1862   if (!item.GetLabel().empty())
1863     SetLabel(item.GetLabel());
1864   if (!item.GetLabel2().empty())
1865     SetLabel2(item.GetLabel2());
1866   if (!item.GetArt().empty())
1867   {
1868     if (item.IsVideo())
1869       AppendArt(item.GetArt());
1870     else
1871       SetArt(item.GetArt());
1872   }
1873   AppendProperties(item);
1874   UpdateMimeType();
1875 }
1876
1877 void CFileItem::SetFromVideoInfoTag(const CVideoInfoTag &video)
1878 {
1879   if (!video.m_strTitle.empty())
1880     SetLabel(video.m_strTitle);
1881   if (video.m_strFileNameAndPath.empty())
1882   {
1883     m_strPath = video.m_strPath;
1884     URIUtils::AddSlashAtEnd(m_strPath);
1885     m_bIsFolder = true;
1886   }
1887   else
1888   {
1889     m_strPath = video.m_strFileNameAndPath;
1890     m_bIsFolder = false;
1891   }
1892
1893   if (m_videoInfoTag)
1894     *m_videoInfoTag = video;
1895   else
1896     m_videoInfoTag = new CVideoInfoTag(video);
1897
1898   if (video.m_iSeason == 0)
1899     SetProperty("isspecial", "true");
1900   FillInDefaultIcon();
1901   FillInMimeType(false);
1902 }
1903
1904 namespace
1905 {
1906 class CPropertySaveHelper
1907 {
1908 public:
1909   CPropertySaveHelper(CFileItem& item, const std::string& property, const std::string& value)
1910     : m_item(item), m_property(property), m_value(value)
1911   {
1912   }
1913
1914   bool NeedsSave() const { return !m_value.empty() || m_item.HasProperty(m_property); }
1915
1916   std::string GetValueToSave(const std::string& currentValue) const
1917   {
1918     std::string value;
1919
1920     if (!m_value.empty())
1921     {
1922       // Overwrite whatever we have; remember what we had originally.
1923       if (!m_item.HasProperty(m_property))
1924         m_item.SetProperty(m_property, currentValue);
1925
1926       value = m_value;
1927     }
1928     else if (m_item.HasProperty(m_property))
1929     {
1930       // Restore original value
1931       value = m_item.GetProperty(m_property).asString();
1932       m_item.ClearProperty(m_property);
1933     }
1934
1935     return value;
1936   }
1937
1938 private:
1939   CFileItem& m_item;
1940   const std::string m_property;
1941   const std::string m_value;
1942 };
1943 } // unnamed namespace
1944
1945 void CFileItem::SetFromMusicInfoTag(const MUSIC_INFO::CMusicInfoTag& music)
1946 {
1947   const std::string path = GetPath();
1948   if (path.empty())
1949   {
1950     SetPath(music.GetURL());
1951   }
1952   else
1953   {
1954     const CPropertySaveHelper dynpath(*this, "OriginalDynPath", music.GetURL());
1955     if (dynpath.NeedsSave())
1956       SetDynPath(dynpath.GetValueToSave(m_strDynPath));
1957   }
1958
1959   const CPropertySaveHelper label(*this, "OriginalLabel", music.GetTitle());
1960   if (label.NeedsSave())
1961     SetLabel(label.GetValueToSave(GetLabel()));
1962
1963   const CPropertySaveHelper thumb(*this, "OriginalThumb", music.GetStationArt());
1964   if (thumb.NeedsSave())
1965     SetArt("thumb", thumb.GetValueToSave(GetArt("thumb")));
1966
1967   *GetMusicInfoTag() = music;
1968   FillInDefaultIcon();
1969   FillInMimeType(false);
1970 }
1971
1972 void CFileItem::SetFromAlbum(const CAlbum &album)
1973 {
1974   if (!album.strAlbum.empty())
1975     SetLabel(album.strAlbum);
1976   m_bIsFolder = true;
1977   m_strLabel2 = album.GetAlbumArtistString();
1978   GetMusicInfoTag()->SetAlbum(album);
1979
1980   if (album.art.empty())
1981     SetArt("icon", "DefaultAlbumCover.png");
1982   else
1983     SetArt(album.art);
1984
1985   m_bIsAlbum = true;
1986   CMusicDatabase::SetPropertiesFromAlbum(*this,album);
1987   FillInMimeType(false);
1988 }
1989
1990 void CFileItem::SetFromSong(const CSong &song)
1991 {
1992   if (!song.strTitle.empty())
1993     SetLabel(song.strTitle);
1994   if (song.idSong > 0)
1995   {
1996     std::string strExt = URIUtils::GetExtension(song.strFileName);
1997     m_strPath = StringUtils::Format("musicdb://songs/{}{}", song.idSong, strExt);
1998   }
1999   else if (!song.strFileName.empty())
2000     m_strPath = song.strFileName;
2001   GetMusicInfoTag()->SetSong(song);
2002   m_lStartOffset = song.iStartOffset;
2003   m_lStartPartNumber = 1;
2004   SetProperty("item_start", song.iStartOffset);
2005   m_lEndOffset = song.iEndOffset;
2006   if (!song.strThumb.empty())
2007     SetArt("thumb", song.strThumb);
2008   FillInMimeType(false);
2009 }
2010
2011 std::string CFileItem::GetOpticalMediaPath() const
2012 {
2013   std::string path;
2014   path = URIUtils::AddFileToFolder(GetPath(), "VIDEO_TS.IFO");
2015   if (CFile::Exists(path))
2016     return path;
2017
2018   path = URIUtils::AddFileToFolder(GetPath(), "VIDEO_TS", "VIDEO_TS.IFO");
2019   if (CFile::Exists(path))
2020     return path;
2021
2022 #ifdef HAVE_LIBBLURAY
2023   path = URIUtils::AddFileToFolder(GetPath(), "index.bdmv");
2024   if (CFile::Exists(path))
2025     return path;
2026
2027   path = URIUtils::AddFileToFolder(GetPath(), "BDMV", "index.bdmv");
2028   if (CFile::Exists(path))
2029     return path;
2030
2031   path = URIUtils::AddFileToFolder(GetPath(), "INDEX.BDM");
2032   if (CFile::Exists(path))
2033     return path;
2034
2035   path = URIUtils::AddFileToFolder(GetPath(), "BDMV", "INDEX.BDM");
2036   if (CFile::Exists(path))
2037     return path;
2038 #endif
2039   return std::string();
2040 }
2041
2042 /**
2043 * @todo Ideally this (and SetPath) would not be available outside of construction
2044 * for CFileItem objects, or at least restricted to essentially be equivalent
2045 * to construction. This would require re-formulating a bunch of CFileItem
2046 * construction, and also allowing CFileItemList to have its own (public)
2047 * SetURL() function, so for now we give direct access.
2048 */
2049 void CFileItem::SetURL(const CURL& url)
2050 {
2051   m_strPath = url.Get();
2052 }
2053
2054 const CURL CFileItem::GetURL() const
2055 {
2056   CURL url(m_strPath);
2057   return url;
2058 }
2059
2060 bool CFileItem::IsURL(const CURL& url) const
2061 {
2062   return IsPath(url.Get());
2063 }
2064
2065 bool CFileItem::IsPath(const std::string& path, bool ignoreURLOptions /* = false */) const
2066 {
2067   return URIUtils::PathEquals(m_strPath, path, false, ignoreURLOptions);
2068 }
2069
2070 void CFileItem::SetDynURL(const CURL& url)
2071 {
2072   m_strDynPath = url.Get();
2073 }
2074
2075 const CURL CFileItem::GetDynURL() const
2076 {
2077   if (!m_strDynPath.empty())
2078   {
2079     CURL url(m_strDynPath);
2080     return url;
2081   }
2082   else
2083   {
2084     CURL url(m_strPath);
2085     return url;
2086   }
2087 }
2088
2089 const std::string &CFileItem::GetDynPath() const
2090 {
2091   if (!m_strDynPath.empty())
2092     return m_strDynPath;
2093   else
2094     return m_strPath;
2095 }
2096
2097 void CFileItem::SetDynPath(const std::string &path)
2098 {
2099   m_strDynPath = path;
2100 }
2101
2102 void CFileItem::SetCueDocument(const CCueDocumentPtr& cuePtr)
2103 {
2104   m_cueDocument = cuePtr;
2105 }
2106
2107 void CFileItem::LoadEmbeddedCue()
2108 {
2109   CMusicInfoTag& tag = *GetMusicInfoTag();
2110   if (!tag.Loaded())
2111     return;
2112
2113   const std::string embeddedCue = tag.GetCueSheet();
2114   if (!embeddedCue.empty())
2115   {
2116     CCueDocumentPtr cuesheet(new CCueDocument);
2117     if (cuesheet->ParseTag(embeddedCue))
2118     {
2119       std::vector<std::string> MediaFileVec;
2120       cuesheet->GetMediaFiles(MediaFileVec);
2121       for (std::vector<std::string>::iterator itMedia = MediaFileVec.begin();
2122            itMedia != MediaFileVec.end(); ++itMedia)
2123         cuesheet->UpdateMediaFile(*itMedia, GetPath());
2124       SetCueDocument(cuesheet);
2125     }
2126     // Clear cuesheet tag having added it to item
2127     tag.SetCueSheet("");
2128   }
2129 }
2130
2131 bool CFileItem::HasCueDocument() const
2132 {
2133   return (m_cueDocument.get() != nullptr);
2134 }
2135
2136 bool CFileItem::LoadTracksFromCueDocument(CFileItemList& scannedItems)
2137 {
2138   if (!m_cueDocument)
2139     return false;
2140
2141   const CMusicInfoTag& tag = *GetMusicInfoTag();
2142
2143   VECSONGS tracks;
2144   m_cueDocument->GetSongs(tracks);
2145
2146   bool oneFilePerTrack = m_cueDocument->IsOneFilePerTrack();
2147   m_cueDocument.reset();
2148
2149   int tracksFound = 0;
2150   for (VECSONGS::iterator it = tracks.begin(); it != tracks.end(); ++it)
2151   {
2152     CSong& song = *it;
2153     if (song.strFileName == GetPath())
2154     {
2155       if (tag.Loaded())
2156       {
2157         if (song.strAlbum.empty() && !tag.GetAlbum().empty())
2158           song.strAlbum = tag.GetAlbum();
2159         //Pass album artist to final MusicInfoTag object via setting song album artist vector.
2160         if (song.GetAlbumArtist().empty() && !tag.GetAlbumArtist().empty())
2161           song.SetAlbumArtist(tag.GetAlbumArtist());
2162         if (song.genre.empty() && !tag.GetGenre().empty())
2163           song.genre = tag.GetGenre();
2164         //Pass artist to final MusicInfoTag object via setting song artist description string only.
2165         //Artist credits not used during loading from cue sheet.
2166         if (song.strArtistDesc.empty() && !tag.GetArtistString().empty())
2167           song.strArtistDesc = tag.GetArtistString();
2168         if (tag.GetDiscNumber())
2169           song.iTrack |= (tag.GetDiscNumber() << 16); // see CMusicInfoTag::GetDiscNumber()
2170         if (!tag.GetCueSheet().empty())
2171           song.strCueSheet = tag.GetCueSheet();
2172
2173         if (tag.GetYear())
2174           song.strReleaseDate = tag.GetReleaseDate();
2175         if (song.embeddedArt.Empty() && !tag.GetCoverArtInfo().Empty())
2176           song.embeddedArt = tag.GetCoverArtInfo();
2177       }
2178
2179       if (!song.iDuration && tag.GetDuration() > 0)
2180       { // must be the last song
2181         song.iDuration = CUtil::ConvertMilliSecsToSecsIntRounded(CUtil::ConvertSecsToMilliSecs(tag.GetDuration()) - song.iStartOffset);
2182       }
2183       if ( tag.Loaded() && oneFilePerTrack && ! ( tag.GetAlbum().empty() || tag.GetArtist().empty() || tag.GetTitle().empty() ) )
2184       {
2185         // If there are multiple files in a cue file, the tags from the files should be preferred if they exist.
2186         scannedItems.Add(std::make_shared<CFileItem>(song, tag));
2187       }
2188       else
2189       {
2190         scannedItems.Add(std::make_shared<CFileItem>(song));
2191       }
2192       ++tracksFound;
2193     }
2194   }
2195   return tracksFound != 0;
2196 }
2197
2198 /////////////////////////////////////////////////////////////////////////////////
2199 /////
2200 ///// CFileItemList
2201 /////
2202 //////////////////////////////////////////////////////////////////////////////////
2203
2204 CFileItemList::CFileItemList()
2205 : CFileItem("", true)
2206 {
2207 }
2208
2209 CFileItemList::CFileItemList(const std::string& strPath)
2210 : CFileItem(strPath, true)
2211 {
2212 }
2213
2214 CFileItemList::~CFileItemList()
2215 {
2216   Clear();
2217 }
2218
2219 CFileItemPtr CFileItemList::operator[] (int iItem)
2220 {
2221   return Get(iItem);
2222 }
2223
2224 const CFileItemPtr CFileItemList::operator[] (int iItem) const
2225 {
2226   return Get(iItem);
2227 }
2228
2229 CFileItemPtr CFileItemList::operator[] (const std::string& strPath)
2230 {
2231   return Get(strPath);
2232 }
2233
2234 const CFileItemPtr CFileItemList::operator[] (const std::string& strPath) const
2235 {
2236   return Get(strPath);
2237 }
2238
2239 void CFileItemList::SetIgnoreURLOptions(bool ignoreURLOptions)
2240 {
2241   m_ignoreURLOptions = ignoreURLOptions;
2242
2243   if (m_fastLookup)
2244   {
2245     m_fastLookup = false; // Force SetFastlookup to clear map
2246     SetFastLookup(true);  // and regenerate map
2247   }
2248 }
2249
2250 void CFileItemList::SetFastLookup(bool fastLookup)
2251 {
2252   std::unique_lock<CCriticalSection> lock(m_lock);
2253
2254   if (fastLookup && !m_fastLookup)
2255   { // generate the map
2256     m_map.clear();
2257     for (unsigned int i=0; i < m_items.size(); i++)
2258     {
2259       CFileItemPtr pItem = m_items[i];
2260       m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
2261     }
2262   }
2263   if (!fastLookup && m_fastLookup)
2264     m_map.clear();
2265   m_fastLookup = fastLookup;
2266 }
2267
2268 bool CFileItemList::Contains(const std::string& fileName) const
2269 {
2270   std::unique_lock<CCriticalSection> lock(m_lock);
2271
2272   if (m_fastLookup)
2273     return m_map.find(m_ignoreURLOptions ? CURL(fileName).GetWithoutOptions() : fileName) != m_map.end();
2274
2275   // slow method...
2276   for (unsigned int i = 0; i < m_items.size(); i++)
2277   {
2278     const CFileItemPtr pItem = m_items[i];
2279     if (pItem->IsPath(m_ignoreURLOptions ? CURL(fileName).GetWithoutOptions() : fileName))
2280       return true;
2281   }
2282   return false;
2283 }
2284
2285 void CFileItemList::Clear()
2286 {
2287   std::unique_lock<CCriticalSection> lock(m_lock);
2288
2289   ClearItems();
2290   m_sortDescription.sortBy = SortByNone;
2291   m_sortDescription.sortOrder = SortOrderNone;
2292   m_sortDescription.sortAttributes = SortAttributeNone;
2293   m_sortIgnoreFolders = false;
2294   m_cacheToDisc = CACHE_IF_SLOW;
2295   m_sortDetails.clear();
2296   m_replaceListing = false;
2297   m_content.clear();
2298 }
2299
2300 void CFileItemList::ClearItems()
2301 {
2302   std::unique_lock<CCriticalSection> lock(m_lock);
2303   // make sure we free the memory of the items (these are GUIControls which may have allocated resources)
2304   FreeMemory();
2305   for (unsigned int i = 0; i < m_items.size(); i++)
2306   {
2307     CFileItemPtr item = m_items[i];
2308     item->FreeMemory();
2309   }
2310   m_items.clear();
2311   m_map.clear();
2312 }
2313
2314 void CFileItemList::Add(CFileItemPtr pItem)
2315 {
2316   std::unique_lock<CCriticalSection> lock(m_lock);
2317   if (m_fastLookup)
2318     m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
2319   m_items.emplace_back(std::move(pItem));
2320 }
2321
2322 void CFileItemList::Add(CFileItem&& item)
2323 {
2324   std::unique_lock<CCriticalSection> lock(m_lock);
2325   auto ptr = std::make_shared<CFileItem>(std::move(item));
2326   if (m_fastLookup)
2327     m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(ptr->GetPath()).GetWithoutOptions() : ptr->GetPath(), ptr));
2328   m_items.emplace_back(std::move(ptr));
2329 }
2330
2331 void CFileItemList::AddFront(const CFileItemPtr &pItem, int itemPosition)
2332 {
2333   std::unique_lock<CCriticalSection> lock(m_lock);
2334
2335   if (itemPosition >= 0)
2336   {
2337     m_items.insert(m_items.begin()+itemPosition, pItem);
2338   }
2339   else
2340   {
2341     m_items.insert(m_items.begin()+(m_items.size()+itemPosition), pItem);
2342   }
2343   if (m_fastLookup)
2344   {
2345     m_map.insert(MAPFILEITEMSPAIR(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath(), pItem));
2346   }
2347 }
2348
2349 void CFileItemList::Remove(CFileItem* pItem)
2350 {
2351   std::unique_lock<CCriticalSection> lock(m_lock);
2352
2353   for (IVECFILEITEMS it = m_items.begin(); it != m_items.end(); ++it)
2354   {
2355     if (pItem == it->get())
2356     {
2357       m_items.erase(it);
2358       if (m_fastLookup)
2359       {
2360         m_map.erase(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath());
2361       }
2362       break;
2363     }
2364   }
2365 }
2366
2367 VECFILEITEMS::iterator CFileItemList::erase(VECFILEITEMS::iterator first,
2368                                             VECFILEITEMS::iterator last)
2369 {
2370   std::unique_lock<CCriticalSection> lock(m_lock);
2371   return m_items.erase(first, last);
2372 }
2373
2374 void CFileItemList::Remove(int iItem)
2375 {
2376   std::unique_lock<CCriticalSection> lock(m_lock);
2377
2378   if (iItem >= 0 && iItem < Size())
2379   {
2380     CFileItemPtr pItem = *(m_items.begin() + iItem);
2381     if (m_fastLookup)
2382     {
2383       m_map.erase(m_ignoreURLOptions ? CURL(pItem->GetPath()).GetWithoutOptions() : pItem->GetPath());
2384     }
2385     m_items.erase(m_items.begin() + iItem);
2386   }
2387 }
2388
2389 void CFileItemList::Append(const CFileItemList& itemlist)
2390 {
2391   std::unique_lock<CCriticalSection> lock(m_lock);
2392
2393   for (int i = 0; i < itemlist.Size(); ++i)
2394     Add(itemlist[i]);
2395 }
2396
2397 void CFileItemList::Assign(const CFileItemList& itemlist, bool append)
2398 {
2399   std::unique_lock<CCriticalSection> lock(m_lock);
2400   if (!append)
2401     Clear();
2402   Append(itemlist);
2403   SetPath(itemlist.GetPath());
2404   SetLabel(itemlist.GetLabel());
2405   m_sortDetails = itemlist.m_sortDetails;
2406   m_sortDescription = itemlist.m_sortDescription;
2407   m_replaceListing = itemlist.m_replaceListing;
2408   m_content = itemlist.m_content;
2409   m_mapProperties = itemlist.m_mapProperties;
2410   m_cacheToDisc = itemlist.m_cacheToDisc;
2411 }
2412
2413 bool CFileItemList::Copy(const CFileItemList& items, bool copyItems /* = true */)
2414 {
2415   // assign all CFileItem parts
2416   *static_cast<CFileItem*>(this) = static_cast<const CFileItem&>(items);
2417
2418   // assign the rest of the CFileItemList properties
2419   m_replaceListing  = items.m_replaceListing;
2420   m_content         = items.m_content;
2421   m_mapProperties   = items.m_mapProperties;
2422   m_cacheToDisc     = items.m_cacheToDisc;
2423   m_sortDetails     = items.m_sortDetails;
2424   m_sortDescription = items.m_sortDescription;
2425   m_sortIgnoreFolders = items.m_sortIgnoreFolders;
2426
2427   if (copyItems)
2428   {
2429     // make a copy of each item
2430     for (int i = 0; i < items.Size(); i++)
2431     {
2432       CFileItemPtr newItem(new CFileItem(*items[i]));
2433       Add(newItem);
2434     }
2435   }
2436
2437   return true;
2438 }
2439
2440 CFileItemPtr CFileItemList::Get(int iItem) const
2441 {
2442   std::unique_lock<CCriticalSection> lock(m_lock);
2443
2444   if (iItem > -1 && iItem < (int)m_items.size())
2445     return m_items[iItem];
2446
2447   return CFileItemPtr();
2448 }
2449
2450 CFileItemPtr CFileItemList::Get(const std::string& strPath) const
2451 {
2452   std::unique_lock<CCriticalSection> lock(m_lock);
2453
2454   if (m_fastLookup)
2455   {
2456     MAPFILEITEMS::const_iterator it =
2457         m_map.find(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath);
2458     if (it != m_map.end())
2459       return it->second;
2460
2461     return CFileItemPtr();
2462   }
2463   // slow method...
2464   for (unsigned int i = 0; i < m_items.size(); i++)
2465   {
2466     CFileItemPtr pItem = m_items[i];
2467     if (pItem->IsPath(m_ignoreURLOptions ? CURL(strPath).GetWithoutOptions() : strPath))
2468       return pItem;
2469   }
2470
2471   return CFileItemPtr();
2472 }
2473
2474 int CFileItemList::Size() const
2475 {
2476   std::unique_lock<CCriticalSection> lock(m_lock);
2477   return (int)m_items.size();
2478 }
2479
2480 bool CFileItemList::IsEmpty() const
2481 {
2482   std::unique_lock<CCriticalSection> lock(m_lock);
2483   return m_items.empty();
2484 }
2485
2486 void CFileItemList::Reserve(size_t iCount)
2487 {
2488   std::unique_lock<CCriticalSection> lock(m_lock);
2489   m_items.reserve(iCount);
2490 }
2491
2492 void CFileItemList::Sort(FILEITEMLISTCOMPARISONFUNC func)
2493 {
2494   std::unique_lock<CCriticalSection> lock(m_lock);
2495   std::stable_sort(m_items.begin(), m_items.end(), func);
2496 }
2497
2498 void CFileItemList::FillSortFields(FILEITEMFILLFUNC func)
2499 {
2500   std::unique_lock<CCriticalSection> lock(m_lock);
2501   std::for_each(m_items.begin(), m_items.end(), func);
2502 }
2503
2504 void CFileItemList::Sort(SortBy sortBy, SortOrder sortOrder, SortAttribute sortAttributes /* = SortAttributeNone */)
2505 {
2506   if (sortBy == SortByNone ||
2507      (m_sortDescription.sortBy == sortBy && m_sortDescription.sortOrder == sortOrder &&
2508       m_sortDescription.sortAttributes == sortAttributes))
2509     return;
2510
2511   SortDescription sorting;
2512   sorting.sortBy = sortBy;
2513   sorting.sortOrder = sortOrder;
2514   sorting.sortAttributes = sortAttributes;
2515
2516   Sort(sorting);
2517   m_sortDescription = sorting;
2518 }
2519
2520 void CFileItemList::Sort(SortDescription sortDescription)
2521 {
2522   if (sortDescription.sortBy == SortByFile || sortDescription.sortBy == SortBySortTitle ||
2523       sortDescription.sortBy == SortByOriginalTitle || sortDescription.sortBy == SortByDateAdded ||
2524       sortDescription.sortBy == SortByRating || sortDescription.sortBy == SortByYear ||
2525       sortDescription.sortBy == SortByPlaylistOrder || sortDescription.sortBy == SortByLastPlayed ||
2526       sortDescription.sortBy == SortByPlaycount)
2527     sortDescription.sortAttributes = (SortAttribute)((int)sortDescription.sortAttributes | SortAttributeIgnoreFolders);
2528
2529   if (sortDescription.sortBy == SortByNone ||
2530      (m_sortDescription.sortBy == sortDescription.sortBy && m_sortDescription.sortOrder == sortDescription.sortOrder &&
2531       m_sortDescription.sortAttributes == sortDescription.sortAttributes))
2532     return;
2533
2534   if (m_sortIgnoreFolders)
2535     sortDescription.sortAttributes = (SortAttribute)((int)sortDescription.sortAttributes | SortAttributeIgnoreFolders);
2536
2537   const Fields fields = SortUtils::GetFieldsForSorting(sortDescription.sortBy);
2538   SortItems sortItems((size_t)Size());
2539   for (int index = 0; index < Size(); index++)
2540   {
2541     sortItems[index] = std::make_shared<SortItem>();
2542     m_items[index]->ToSortable(*sortItems[index], fields);
2543     (*sortItems[index])[FieldId] = index;
2544   }
2545
2546   // do the sorting
2547   SortUtils::Sort(sortDescription, sortItems);
2548
2549   // apply the new order to the existing CFileItems
2550   VECFILEITEMS sortedFileItems;
2551   sortedFileItems.reserve(Size());
2552   for (SortItems::const_iterator it = sortItems.begin(); it != sortItems.end(); ++it)
2553   {
2554     CFileItemPtr item = m_items[(int)(*it)->at(FieldId).asInteger()];
2555     // Set the sort label in the CFileItem
2556     item->SetSortLabel((*it)->at(FieldSort).asWideString());
2557
2558     sortedFileItems.push_back(item);
2559   }
2560
2561   // replace the current list with the re-ordered one
2562   m_items = std::move(sortedFileItems);
2563 }
2564
2565 void CFileItemList::Randomize()
2566 {
2567   std::unique_lock<CCriticalSection> lock(m_lock);
2568   KODI::UTILS::RandomShuffle(m_items.begin(), m_items.end());
2569 }
2570
2571 void CFileItemList::Archive(CArchive& ar)
2572 {
2573   std::unique_lock<CCriticalSection> lock(m_lock);
2574   if (ar.IsStoring())
2575   {
2576     CFileItem::Archive(ar);
2577
2578     int i = 0;
2579     if (!m_items.empty() && m_items[0]->IsParentFolder())
2580       i = 1;
2581
2582     ar << (int)(m_items.size() - i);
2583
2584     ar << m_ignoreURLOptions;
2585
2586     ar << m_fastLookup;
2587
2588     ar << (int)m_sortDescription.sortBy;
2589     ar << (int)m_sortDescription.sortOrder;
2590     ar << (int)m_sortDescription.sortAttributes;
2591     ar << m_sortIgnoreFolders;
2592     ar << (int)m_cacheToDisc;
2593
2594     ar << (int)m_sortDetails.size();
2595     for (unsigned int j = 0; j < m_sortDetails.size(); ++j)
2596     {
2597       const GUIViewSortDetails &details = m_sortDetails[j];
2598       ar << (int)details.m_sortDescription.sortBy;
2599       ar << (int)details.m_sortDescription.sortOrder;
2600       ar << (int)details.m_sortDescription.sortAttributes;
2601       ar << details.m_buttonLabel;
2602       ar << details.m_labelMasks.m_strLabelFile;
2603       ar << details.m_labelMasks.m_strLabelFolder;
2604       ar << details.m_labelMasks.m_strLabel2File;
2605       ar << details.m_labelMasks.m_strLabel2Folder;
2606     }
2607
2608     ar << m_content;
2609
2610     for (; i < (int)m_items.size(); ++i)
2611     {
2612       CFileItemPtr pItem = m_items[i];
2613       ar << *pItem;
2614     }
2615   }
2616   else
2617   {
2618     CFileItemPtr pParent;
2619     if (!IsEmpty())
2620     {
2621       CFileItemPtr pItem=m_items[0];
2622       if (pItem->IsParentFolder())
2623         pParent = std::make_shared<CFileItem>(*pItem);
2624     }
2625
2626     SetIgnoreURLOptions(false);
2627     SetFastLookup(false);
2628     Clear();
2629
2630     CFileItem::Archive(ar);
2631
2632     int iSize = 0;
2633     ar >> iSize;
2634     if (iSize <= 0)
2635       return ;
2636
2637     if (pParent)
2638     {
2639       m_items.reserve(iSize + 1);
2640       m_items.push_back(pParent);
2641     }
2642     else
2643       m_items.reserve(iSize);
2644
2645     bool ignoreURLOptions = false;
2646     ar >> ignoreURLOptions;
2647
2648     bool fastLookup = false;
2649     ar >> fastLookup;
2650
2651     int tempint;
2652     ar >> tempint;
2653     m_sortDescription.sortBy = (SortBy)tempint;
2654     ar >> tempint;
2655     m_sortDescription.sortOrder = (SortOrder)tempint;
2656     ar >> tempint;
2657     m_sortDescription.sortAttributes = (SortAttribute)tempint;
2658     ar >> m_sortIgnoreFolders;
2659     ar >> tempint;
2660     m_cacheToDisc = CACHE_TYPE(tempint);
2661
2662     unsigned int detailSize = 0;
2663     ar >> detailSize;
2664     for (unsigned int j = 0; j < detailSize; ++j)
2665     {
2666       GUIViewSortDetails details;
2667       ar >> tempint;
2668       details.m_sortDescription.sortBy = (SortBy)tempint;
2669       ar >> tempint;
2670       details.m_sortDescription.sortOrder = (SortOrder)tempint;
2671       ar >> tempint;
2672       details.m_sortDescription.sortAttributes = (SortAttribute)tempint;
2673       ar >> details.m_buttonLabel;
2674       ar >> details.m_labelMasks.m_strLabelFile;
2675       ar >> details.m_labelMasks.m_strLabelFolder;
2676       ar >> details.m_labelMasks.m_strLabel2File;
2677       ar >> details.m_labelMasks.m_strLabel2Folder;
2678       m_sortDetails.push_back(details);
2679     }
2680
2681     ar >> m_content;
2682
2683     for (int i = 0; i < iSize; ++i)
2684     {
2685       CFileItemPtr pItem(new CFileItem);
2686       ar >> *pItem;
2687       Add(pItem);
2688     }
2689
2690     SetIgnoreURLOptions(ignoreURLOptions);
2691     SetFastLookup(fastLookup);
2692   }
2693 }
2694
2695 void CFileItemList::FillInDefaultIcons()
2696 {
2697   std::unique_lock<CCriticalSection> lock(m_lock);
2698   for (int i = 0; i < (int)m_items.size(); ++i)
2699   {
2700     CFileItemPtr pItem = m_items[i];
2701     pItem->FillInDefaultIcon();
2702   }
2703 }
2704
2705 int CFileItemList::GetFolderCount() const
2706 {
2707   std::unique_lock<CCriticalSection> lock(m_lock);
2708   int nFolderCount = 0;
2709   for (int i = 0; i < (int)m_items.size(); i++)
2710   {
2711     CFileItemPtr pItem = m_items[i];
2712     if (pItem->m_bIsFolder)
2713       nFolderCount++;
2714   }
2715
2716   return nFolderCount;
2717 }
2718
2719 int CFileItemList::GetObjectCount() const
2720 {
2721   std::unique_lock<CCriticalSection> lock(m_lock);
2722
2723   int numObjects = (int)m_items.size();
2724   if (numObjects && m_items[0]->IsParentFolder())
2725     numObjects--;
2726
2727   return numObjects;
2728 }
2729
2730 int CFileItemList::GetFileCount() const
2731 {
2732   std::unique_lock<CCriticalSection> lock(m_lock);
2733   int nFileCount = 0;
2734   for (int i = 0; i < (int)m_items.size(); i++)
2735   {
2736     CFileItemPtr pItem = m_items[i];
2737     if (!pItem->m_bIsFolder)
2738       nFileCount++;
2739   }
2740
2741   return nFileCount;
2742 }
2743
2744 int CFileItemList::GetSelectedCount() const
2745 {
2746   std::unique_lock<CCriticalSection> lock(m_lock);
2747   int count = 0;
2748   for (int i = 0; i < (int)m_items.size(); i++)
2749   {
2750     CFileItemPtr pItem = m_items[i];
2751     if (pItem->IsSelected())
2752       count++;
2753   }
2754
2755   return count;
2756 }
2757
2758 void CFileItemList::FilterCueItems()
2759 {
2760   std::unique_lock<CCriticalSection> lock(m_lock);
2761   // Handle .CUE sheet files...
2762   std::vector<std::string> itemstodelete;
2763   for (int i = 0; i < (int)m_items.size(); i++)
2764   {
2765     CFileItemPtr pItem = m_items[i];
2766     if (!pItem->m_bIsFolder)
2767     { // see if it's a .CUE sheet
2768       if (pItem->IsCUESheet())
2769       {
2770         CCueDocumentPtr cuesheet(new CCueDocument);
2771         if (cuesheet->ParseFile(pItem->GetPath()))
2772         {
2773           std::vector<std::string> MediaFileVec;
2774           cuesheet->GetMediaFiles(MediaFileVec);
2775
2776           // queue the cue sheet and the underlying media file for deletion
2777           for (std::vector<std::string>::iterator itMedia = MediaFileVec.begin();
2778                itMedia != MediaFileVec.end(); ++itMedia)
2779           {
2780             std::string strMediaFile = *itMedia;
2781             std::string fileFromCue = strMediaFile; // save the file from the cue we're matching against,
2782                                                    // as we're going to search for others here...
2783             bool bFoundMediaFile = CFile::Exists(strMediaFile);
2784             if (!bFoundMediaFile)
2785             {
2786               // try file in same dir, not matching case...
2787               if (Contains(strMediaFile))
2788               {
2789                 bFoundMediaFile = true;
2790               }
2791               else
2792               {
2793                 // try removing the .cue extension...
2794                 strMediaFile = pItem->GetPath();
2795                 URIUtils::RemoveExtension(strMediaFile);
2796                 CFileItem item(strMediaFile, false);
2797                 if (item.IsAudio() && Contains(strMediaFile))
2798                 {
2799                   bFoundMediaFile = true;
2800                 }
2801                 else
2802                 { // try replacing the extension with one of our allowed ones.
2803                   std::vector<std::string> extensions = StringUtils::Split(CServiceBroker::GetFileExtensionProvider().GetMusicExtensions(), "|");
2804                   for (std::vector<std::string>::const_iterator i = extensions.begin(); i != extensions.end(); ++i)
2805                   {
2806                     strMediaFile = URIUtils::ReplaceExtension(pItem->GetPath(), *i);
2807                     CFileItem item(strMediaFile, false);
2808                     if (!item.IsCUESheet() && !item.IsPlayList() && Contains(strMediaFile))
2809                     {
2810                       bFoundMediaFile = true;
2811                       break;
2812                     }
2813                   }
2814                 }
2815               }
2816             }
2817             if (bFoundMediaFile)
2818             {
2819               cuesheet->UpdateMediaFile(fileFromCue, strMediaFile);
2820               // apply CUE for later processing
2821               for (int j = 0; j < (int)m_items.size(); j++)
2822               {
2823                 CFileItemPtr pItem = m_items[j];
2824                 if (StringUtils::CompareNoCase(pItem->GetPath(), strMediaFile) == 0)
2825                   pItem->SetCueDocument(cuesheet);
2826               }
2827             }
2828           }
2829         }
2830         itemstodelete.push_back(pItem->GetPath());
2831       }
2832     }
2833   }
2834   // now delete the .CUE files.
2835   for (int i = 0; i < (int)itemstodelete.size(); i++)
2836   {
2837     for (int j = 0; j < (int)m_items.size(); j++)
2838     {
2839       CFileItemPtr pItem = m_items[j];
2840       if (StringUtils::CompareNoCase(pItem->GetPath(), itemstodelete[i]) == 0)
2841       { // delete this item
2842         m_items.erase(m_items.begin() + j);
2843         break;
2844       }
2845     }
2846   }
2847 }
2848
2849 // Remove the extensions from the filenames
2850 void CFileItemList::RemoveExtensions()
2851 {
2852   std::unique_lock<CCriticalSection> lock(m_lock);
2853   for (int i = 0; i < Size(); ++i)
2854     m_items[i]->RemoveExtension();
2855 }
2856
2857 void CFileItemList::Stack(bool stackFiles /* = true */)
2858 {
2859   std::unique_lock<CCriticalSection> lock(m_lock);
2860
2861   // not allowed here
2862   if (IsVirtualDirectoryRoot() ||
2863       IsLiveTV() ||
2864       IsSourcesPath() ||
2865       IsLibraryFolder())
2866     return;
2867
2868   SetProperty("isstacked", true);
2869
2870   // items needs to be sorted for stuff below to work properly
2871   Sort(SortByLabel, SortOrderAscending);
2872
2873   StackFolders();
2874
2875   if (stackFiles)
2876     StackFiles();
2877 }
2878
2879 void CFileItemList::StackFolders()
2880 {
2881   // Precompile our REs
2882   VECCREGEXP folderRegExps;
2883   CRegExp folderRegExp(true, CRegExp::autoUtf8);
2884   const std::vector<std::string>& strFolderRegExps = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_folderStackRegExps;
2885
2886   std::vector<std::string>::const_iterator strExpression = strFolderRegExps.begin();
2887   while (strExpression != strFolderRegExps.end())
2888   {
2889     if (!folderRegExp.RegComp(*strExpression))
2890       CLog::Log(LOGERROR, "{}: Invalid folder stack RegExp:'{}'", __FUNCTION__,
2891                 strExpression->c_str());
2892     else
2893       folderRegExps.push_back(folderRegExp);
2894
2895     ++strExpression;
2896   }
2897
2898   if (!folderRegExp.IsCompiled())
2899   {
2900     CLog::Log(LOGDEBUG, "{}: No stack expressions available. Skipping folder stacking",
2901               __FUNCTION__);
2902     return;
2903   }
2904
2905   // stack folders
2906   for (int i = 0; i < Size(); i++)
2907   {
2908     CFileItemPtr item = Get(i);
2909     // combined the folder checks
2910     if (item->m_bIsFolder)
2911     {
2912       // only check known fast sources?
2913       // NOTES:
2914       // 1. rars and zips may be on slow sources? is this supposed to be allowed?
2915       if( !item->IsRemote()
2916         || item->IsSmb()
2917         || item->IsNfs()
2918         || URIUtils::IsInRAR(item->GetPath())
2919         || URIUtils::IsInZIP(item->GetPath())
2920         || URIUtils::IsOnLAN(item->GetPath())
2921         )
2922       {
2923         // stack cd# folders if contains only a single video file
2924
2925         bool bMatch(false);
2926
2927         VECCREGEXP::iterator expr = folderRegExps.begin();
2928         while (!bMatch && expr != folderRegExps.end())
2929         {
2930           //CLog::Log(LOGDEBUG,"{}: Running expression {} on {}", __FUNCTION__, expr->GetPattern(), item->GetLabel());
2931           bMatch = (expr->RegFind(item->GetLabel().c_str()) != -1);
2932           if (bMatch)
2933           {
2934             CFileItemList items;
2935             CDirectory::GetDirectory(item->GetPath(), items,
2936                                      CServiceBroker::GetFileExtensionProvider().GetVideoExtensions(),
2937                                      DIR_FLAG_DEFAULTS);
2938             // optimized to only traverse listing once by checking for filecount
2939             // and recording last file item for later use
2940             int nFiles = 0;
2941             int index = -1;
2942             for (int j = 0; j < items.Size(); j++)
2943             {
2944               if (!items[j]->m_bIsFolder)
2945               {
2946                 nFiles++;
2947                 index = j;
2948               }
2949
2950               if (nFiles > 1)
2951                 break;
2952             }
2953
2954             if (nFiles == 1)
2955               *item = *items[index];
2956           }
2957           ++expr;
2958         }
2959
2960         // check for dvd folders
2961         if (!bMatch)
2962         {
2963           std::string dvdPath = item->GetOpticalMediaPath();
2964
2965           if (!dvdPath.empty())
2966           {
2967             // NOTE: should this be done for the CD# folders too?
2968             item->m_bIsFolder = false;
2969             item->SetPath(dvdPath);
2970             item->SetLabel2("");
2971             item->SetLabelPreformatted(true);
2972             m_sortDescription.sortBy = SortByNone; /* sorting is now broken */
2973           }
2974         }
2975       }
2976     }
2977   }
2978 }
2979
2980 void CFileItemList::StackFiles()
2981 {
2982   // Precompile our REs
2983   VECCREGEXP stackRegExps;
2984   CRegExp tmpRegExp(true, CRegExp::autoUtf8);
2985   const std::vector<std::string>& strStackRegExps = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoStackRegExps;
2986   std::vector<std::string>::const_iterator strRegExp = strStackRegExps.begin();
2987   while (strRegExp != strStackRegExps.end())
2988   {
2989     if (tmpRegExp.RegComp(*strRegExp))
2990     {
2991       if (tmpRegExp.GetCaptureTotal() == 4)
2992         stackRegExps.push_back(tmpRegExp);
2993       else
2994         CLog::Log(LOGERROR, "Invalid video stack RE ({}). Must have 4 captures.", *strRegExp);
2995     }
2996     ++strRegExp;
2997   }
2998
2999   // now stack the files, some of which may be from the previous stack iteration
3000   int i = 0;
3001   while (i < Size())
3002   {
3003     CFileItemPtr item1 = Get(i);
3004
3005     // skip folders, nfo files, playlists
3006     if (item1->m_bIsFolder
3007       || item1->IsParentFolder()
3008       || item1->IsNFO()
3009       || item1->IsPlayList()
3010       )
3011     {
3012       // increment index
3013       i++;
3014       continue;
3015     }
3016
3017     int64_t               size        = 0;
3018     size_t                offset      = 0;
3019     std::string           stackName;
3020     std::string           file1;
3021     std::string           filePath;
3022     std::vector<int>      stack;
3023     VECCREGEXP::iterator  expr        = stackRegExps.begin();
3024
3025     URIUtils::Split(item1->GetPath(), filePath, file1);
3026     if (URIUtils::HasEncodedFilename(CURL(filePath)))
3027       file1 = CURL::Decode(file1);
3028
3029     int j;
3030     while (expr != stackRegExps.end())
3031     {
3032       if (expr->RegFind(file1, offset) != -1)
3033       {
3034         std::string Title1      = expr->GetMatch(1),
3035                     Volume1     = expr->GetMatch(2),
3036                     Ignore1     = expr->GetMatch(3),
3037                     Extension1  = expr->GetMatch(4);
3038         if (offset)
3039           Title1 = file1.substr(0, expr->GetSubStart(2));
3040         j = i + 1;
3041         while (j < Size())
3042         {
3043           CFileItemPtr item2 = Get(j);
3044
3045           // skip folders, nfo files, playlists
3046           if (item2->m_bIsFolder
3047             || item2->IsParentFolder()
3048             || item2->IsNFO()
3049             || item2->IsPlayList()
3050             )
3051           {
3052             // increment index
3053             j++;
3054             continue;
3055           }
3056
3057           std::string file2, filePath2;
3058           URIUtils::Split(item2->GetPath(), filePath2, file2);
3059           if (URIUtils::HasEncodedFilename(CURL(filePath2)) )
3060             file2 = CURL::Decode(file2);
3061
3062           if (expr->RegFind(file2, offset) != -1)
3063           {
3064             std::string  Title2      = expr->GetMatch(1),
3065                         Volume2     = expr->GetMatch(2),
3066                         Ignore2     = expr->GetMatch(3),
3067                         Extension2  = expr->GetMatch(4);
3068             if (offset)
3069               Title2 = file2.substr(0, expr->GetSubStart(2));
3070             if (StringUtils::EqualsNoCase(Title1, Title2))
3071             {
3072               if (!StringUtils::EqualsNoCase(Volume1, Volume2))
3073               {
3074                 if (StringUtils::EqualsNoCase(Ignore1, Ignore2) &&
3075                     StringUtils::EqualsNoCase(Extension1, Extension2))
3076                 {
3077                   if (stack.empty())
3078                   {
3079                     stackName = Title1 + Ignore1 + Extension1;
3080                     stack.push_back(i);
3081                     size += item1->m_dwSize;
3082                   }
3083                   stack.push_back(j);
3084                   size += item2->m_dwSize;
3085                 }
3086                 else // Sequel
3087                 {
3088                   offset = 0;
3089                   ++expr;
3090                   break;
3091                 }
3092               }
3093               else if (!StringUtils::EqualsNoCase(Ignore1, Ignore2)) // False positive, try again with offset
3094               {
3095                 offset = expr->GetSubStart(3);
3096                 break;
3097               }
3098               else // Extension mismatch
3099               {
3100                 offset = 0;
3101                 ++expr;
3102                 break;
3103               }
3104             }
3105             else // Title mismatch
3106             {
3107               offset = 0;
3108               ++expr;
3109               break;
3110             }
3111           }
3112           else // No match 2, next expression
3113           {
3114             offset = 0;
3115             ++expr;
3116             break;
3117           }
3118           j++;
3119         }
3120         if (j == Size())
3121           expr = stackRegExps.end();
3122       }
3123       else // No match 1
3124       {
3125         offset = 0;
3126         ++expr;
3127       }
3128       if (stack.size() > 1)
3129       {
3130         // have a stack, remove the items and add the stacked item
3131         // dont actually stack a multipart rar set, just remove all items but the first
3132         std::string stackPath;
3133         if (Get(stack[0])->IsRAR())
3134           stackPath = Get(stack[0])->GetPath();
3135         else
3136         {
3137           CStackDirectory dir;
3138           stackPath = dir.ConstructStackPath(*this, stack);
3139         }
3140         item1->SetPath(stackPath);
3141         // clean up list
3142         for (unsigned k = 1; k < stack.size(); k++)
3143           Remove(i+1);
3144         // item->m_bIsFolder = true;  // don't treat stacked files as folders
3145         // the label may be in a different char set from the filename (eg over smb
3146         // the label is converted from utf8, but the filename is not)
3147         if (!CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_FILELISTS_SHOWEXTENSIONS))
3148           URIUtils::RemoveExtension(stackName);
3149
3150         item1->SetLabel(stackName);
3151         item1->m_dwSize = size;
3152         break;
3153       }
3154     }
3155     i++;
3156   }
3157 }
3158
3159 bool CFileItemList::Load(int windowID)
3160 {
3161   CFile file;
3162   auto path = GetDiscFileCache(windowID);
3163   try
3164   {
3165     if (file.Open(path))
3166     {
3167       CArchive ar(&file, CArchive::load);
3168       ar >> *this;
3169       CLog::Log(LOGDEBUG, "Loading items: {}, directory: {} sort method: {}, ascending: {}", Size(),
3170                 CURL::GetRedacted(GetPath()), m_sortDescription.sortBy,
3171                 m_sortDescription.sortOrder == SortOrderAscending ? "true" : "false");
3172       ar.Close();
3173       file.Close();
3174       return true;
3175     }
3176   }
3177   catch(const std::out_of_range&)
3178   {
3179     CLog::Log(LOGERROR, "Corrupt archive: {}", CURL::GetRedacted(path));
3180   }
3181
3182   return false;
3183 }
3184
3185 bool CFileItemList::Save(int windowID)
3186 {
3187   int iSize = Size();
3188   if (iSize <= 0)
3189     return false;
3190
3191   CLog::Log(LOGDEBUG, "Saving fileitems [{}]", CURL::GetRedacted(GetPath()));
3192
3193   CFile file;
3194   std::string cachefile = GetDiscFileCache(windowID);
3195   if (file.OpenForWrite(cachefile, true)) // overwrite always
3196   {
3197     // Before caching save simplified cache file name in every item so the cache file can be
3198     // identifed and removed if the item is updated. List path and options (used for file
3199     // name when list cached) can not be accurately derived from item path.
3200     StringUtils::Replace(cachefile, "special://temp/archive_cache/", "");
3201     StringUtils::Replace(cachefile, ".fi", "");
3202     for (const auto& item : m_items)
3203       item->SetProperty("cachefilename", cachefile);
3204
3205     CArchive ar(&file, CArchive::store);
3206     ar << *this;
3207     CLog::Log(LOGDEBUG, "  -- items: {}, sort method: {}, ascending: {}", iSize,
3208               m_sortDescription.sortBy,
3209               m_sortDescription.sortOrder == SortOrderAscending ? "true" : "false");
3210     ar.Close();
3211     file.Close();
3212     return true;
3213   }
3214
3215   return false;
3216 }
3217
3218 void CFileItemList::RemoveDiscCache(int windowID) const
3219 {
3220   RemoveDiscCache(GetDiscFileCache(windowID));
3221 }
3222
3223 void CFileItemList::RemoveDiscCache(const std::string& cacheFile) const
3224 {
3225   if (CFile::Exists(cacheFile))
3226   {
3227     CLog::Log(LOGDEBUG, "Clearing cached fileitems [{}]", CURL::GetRedacted(GetPath()));
3228     CFile::Delete(cacheFile);
3229   }
3230 }
3231
3232 void CFileItemList::RemoveDiscCacheCRC(const std::string& crc) const
3233 {
3234   std::string cachefile = StringUtils::Format("special://temp/archive_cache/{}.fi", crc);
3235   RemoveDiscCache(cachefile);
3236 }
3237
3238 std::string CFileItemList::GetDiscFileCache(int windowID) const
3239 {
3240   std::string strPath(GetPath());
3241   URIUtils::RemoveSlashAtEnd(strPath);
3242
3243   uint32_t crc = Crc32::ComputeFromLowerCase(strPath);
3244
3245   if (IsCDDA() || IsOnDVD())
3246     return StringUtils::Format("special://temp/archive_cache/r-{:08x}.fi", crc);
3247
3248   if (IsMusicDb())
3249     return StringUtils::Format("special://temp/archive_cache/mdb-{:08x}.fi", crc);
3250
3251   if (IsVideoDb())
3252     return StringUtils::Format("special://temp/archive_cache/vdb-{:08x}.fi", crc);
3253
3254   if (IsSmartPlayList())
3255     return StringUtils::Format("special://temp/archive_cache/sp-{:08x}.fi", crc);
3256
3257   if (windowID)
3258     return StringUtils::Format("special://temp/archive_cache/{}-{:08x}.fi", windowID, crc);
3259
3260   return StringUtils::Format("special://temp/archive_cache/{:08x}.fi", crc);
3261 }
3262
3263 bool CFileItemList::AlwaysCache() const
3264 {
3265   // some database folders are always cached
3266   if (IsMusicDb())
3267     return CMusicDatabaseDirectory::CanCache(GetPath());
3268   if (IsVideoDb())
3269     return CVideoDatabaseDirectory::CanCache(GetPath());
3270   if (IsEPG())
3271     return true; // always cache
3272   return false;
3273 }
3274
3275 std::string CFileItem::GetUserMusicThumb(bool alwaysCheckRemote /* = false */, bool fallbackToFolder /* = false */) const
3276 {
3277   if (m_strPath.empty()
3278    || StringUtils::StartsWithNoCase(m_strPath, "newsmartplaylist://")
3279    || StringUtils::StartsWithNoCase(m_strPath, "newplaylist://")
3280    || m_bIsShareOrDrive
3281    || IsInternetStream()
3282    || URIUtils::IsUPnP(m_strPath)
3283    || (URIUtils::IsFTP(m_strPath) && !CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bFTPThumbs)
3284    || IsPlugin()
3285    || IsAddonsPath()
3286    || IsLibraryFolder()
3287    || IsParentFolder()
3288    || IsMusicDb())
3289     return "";
3290
3291   // we first check for <filename>.tbn or <foldername>.tbn
3292   std::string fileThumb(GetTBNFile());
3293   if (CFile::Exists(fileThumb))
3294     return fileThumb;
3295
3296   // Fall back to folder thumb, if requested
3297   if (!m_bIsFolder && fallbackToFolder)
3298   {
3299     CFileItem item(URIUtils::GetDirectory(m_strPath), true);
3300     return item.GetUserMusicThumb(alwaysCheckRemote);
3301   }
3302
3303   // if a folder, check for folder.jpg
3304   if (m_bIsFolder && !IsFileFolder() && (!IsRemote() || alwaysCheckRemote || CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_MUSICFILES_FINDREMOTETHUMBS)))
3305   {
3306     std::vector<CVariant> thumbs = CServiceBroker::GetSettingsComponent()->GetSettings()->GetList(
3307         CSettings::SETTING_MUSICLIBRARY_MUSICTHUMBS);
3308     for (const auto& i : thumbs)
3309     {
3310       std::string strFileName = i.asString();
3311       std::string folderThumb(GetFolderThumb(strFileName));
3312       if (CFile::Exists(folderThumb))   // folder.jpg
3313         return folderThumb;
3314       size_t period = strFileName.find_last_of('.');
3315       if (period != std::string::npos)
3316       {
3317         std::string ext;
3318         std::string name = strFileName;
3319         std::string folderThumb1 = folderThumb;
3320         name.erase(period);
3321         ext = strFileName.substr(period);
3322         StringUtils::ToUpper(ext);
3323         StringUtils::Replace(folderThumb1, strFileName, name + ext);
3324         if (CFile::Exists(folderThumb1)) // folder.JPG
3325           return folderThumb1;
3326
3327         folderThumb1 = folderThumb;
3328         std::string firstletter = name.substr(0, 1);
3329         StringUtils::ToUpper(firstletter);
3330         name.replace(0, 1, firstletter);
3331         StringUtils::Replace(folderThumb1, strFileName, name + ext);
3332         if (CFile::Exists(folderThumb1)) // Folder.JPG
3333           return folderThumb1;
3334
3335         folderThumb1 = folderThumb;
3336         StringUtils::ToLower(ext);
3337         StringUtils::Replace(folderThumb1, strFileName, name + ext);
3338         if (CFile::Exists(folderThumb1)) // Folder.jpg
3339           return folderThumb1;
3340       }
3341     }
3342   }
3343   // No thumb found
3344   return "";
3345 }
3346
3347 // Gets the .tbn filename from a file or folder name.
3348 // <filename>.ext -> <filename>.tbn
3349 // <foldername>/ -> <foldername>.tbn
3350 std::string CFileItem::GetTBNFile() const
3351 {
3352   std::string thumbFile;
3353   std::string strFile = m_strPath;
3354
3355   if (IsStack())
3356   {
3357     std::string strPath, strReturn;
3358     URIUtils::GetParentPath(m_strPath,strPath);
3359     CFileItem item(CStackDirectory::GetFirstStackedFile(strFile),false);
3360     std::string strTBNFile = item.GetTBNFile();
3361     strReturn = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strTBNFile));
3362     if (CFile::Exists(strReturn))
3363       return strReturn;
3364
3365     strFile = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(CStackDirectory::GetStackedTitlePath(strFile)));
3366   }
3367
3368   if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
3369   {
3370     std::string strPath = URIUtils::GetDirectory(strFile);
3371     std::string strParent;
3372     URIUtils::GetParentPath(strPath,strParent);
3373     strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(m_strPath));
3374   }
3375
3376   CURL url(strFile);
3377   strFile = url.GetFileName();
3378
3379   if (m_bIsFolder && !IsFileFolder())
3380     URIUtils::RemoveSlashAtEnd(strFile);
3381
3382   if (!strFile.empty())
3383   {
3384     if (m_bIsFolder && !IsFileFolder())
3385       thumbFile = strFile + ".tbn"; // folder, so just add ".tbn"
3386     else
3387       thumbFile = URIUtils::ReplaceExtension(strFile, ".tbn");
3388     url.SetFileName(thumbFile);
3389     thumbFile = url.Get();
3390   }
3391   return thumbFile;
3392 }
3393
3394 bool CFileItem::SkipLocalArt() const
3395 {
3396   return (m_strPath.empty()
3397        || StringUtils::StartsWithNoCase(m_strPath, "newsmartplaylist://")
3398        || StringUtils::StartsWithNoCase(m_strPath, "newplaylist://")
3399        || m_bIsShareOrDrive
3400        || IsInternetStream()
3401        || URIUtils::IsUPnP(m_strPath)
3402        || (URIUtils::IsFTP(m_strPath) && !CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bFTPThumbs)
3403        || IsPlugin()
3404        || IsAddonsPath()
3405        || IsLibraryFolder()
3406        || IsParentFolder()
3407        || IsLiveTV()
3408        || IsPVRRecording()
3409        || IsDVD());
3410 }
3411
3412 std::string CFileItem::GetThumbHideIfUnwatched(const CFileItem* item) const
3413 {
3414   const std::shared_ptr<CSettingList> setting(std::dynamic_pointer_cast<CSettingList>(
3415       CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(
3416           CSettings::SETTING_VIDEOLIBRARY_SHOWUNWATCHEDPLOTS)));
3417   if (setting && item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_type == MediaTypeEpisode &&
3418       item->GetVideoInfoTag()->GetPlayCount() == 0 &&
3419       !CSettingUtils::FindIntInList(setting,
3420                                     CSettings::VIDEOLIBRARY_THUMB_SHOW_UNWATCHED_EPISODE) &&
3421       item->HasArt("thumb"))
3422   {
3423     std::string fanArt = item->GetArt("fanart");
3424     if (fanArt.empty())
3425       return "OverlaySpoiler.png";
3426     else
3427       return fanArt;
3428   }
3429
3430   return item->GetArt("thumb");
3431 }
3432
3433 std::string CFileItem::FindLocalArt(const std::string &artFile, bool useFolder) const
3434 {
3435   if (SkipLocalArt())
3436     return "";
3437
3438   std::string thumb;
3439   if (!m_bIsFolder)
3440   {
3441     thumb = GetLocalArt(artFile, false);
3442     if (!thumb.empty() && CFile::Exists(thumb))
3443       return thumb;
3444   }
3445   if ((useFolder || (m_bIsFolder && !IsFileFolder())) && !artFile.empty())
3446   {
3447     std::string thumb2 = GetLocalArt(artFile, true);
3448     if (!thumb2.empty() && thumb2 != thumb && CFile::Exists(thumb2))
3449       return thumb2;
3450   }
3451   return "";
3452 }
3453
3454 std::string CFileItem::GetLocalArtBaseFilename() const
3455 {
3456   bool useFolder = false;
3457   return GetLocalArtBaseFilename(useFolder);
3458 }
3459
3460 std::string CFileItem::GetLocalArtBaseFilename(bool& useFolder) const
3461 {
3462   std::string strFile;
3463   if (IsStack())
3464   {
3465     std::string strPath;
3466     URIUtils::GetParentPath(m_strPath,strPath);
3467     strFile = URIUtils::AddFileToFolder(
3468         strPath, URIUtils::GetFileName(CStackDirectory::GetStackedTitlePath(m_strPath)));
3469   }
3470
3471   std::string file = strFile.empty() ? m_strPath : strFile;
3472   if (URIUtils::IsInRAR(file) || URIUtils::IsInZIP(file))
3473   {
3474     std::string strPath = URIUtils::GetDirectory(file);
3475     std::string strParent;
3476     URIUtils::GetParentPath(strPath,strParent);
3477     strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(file));
3478   }
3479
3480   if (IsMultiPath())
3481     strFile = CMultiPathDirectory::GetFirstPath(m_strPath);
3482
3483   if (IsOpticalMediaFile())
3484   { // optical media files should be treated like folders
3485     useFolder = true;
3486     strFile = GetLocalMetadataPath();
3487   }
3488   else if (useFolder && !(m_bIsFolder && !IsFileFolder()))
3489   {
3490     file = strFile.empty() ? m_strPath : strFile;
3491     strFile = URIUtils::GetDirectory(file);
3492   }
3493
3494   if (strFile.empty())
3495     strFile = GetDynPath();
3496
3497   return strFile;
3498 }
3499
3500 std::string CFileItem::GetLocalArt(const std::string& artFile, bool useFolder) const
3501 {
3502   // no retrieving of empty art files from folders
3503   if (useFolder && artFile.empty())
3504     return "";
3505
3506   std::string strFile = GetLocalArtBaseFilename(useFolder);
3507   if (strFile.empty()) // empty filepath -> nothing to find
3508     return "";
3509
3510   if (useFolder)
3511   {
3512     if (!artFile.empty())
3513       return URIUtils::AddFileToFolder(strFile, artFile);
3514   }
3515   else
3516   {
3517     if (artFile.empty()) // old thumbnail matching
3518       return URIUtils::ReplaceExtension(strFile, ".tbn");
3519     else
3520       return URIUtils::ReplaceExtension(strFile, "-" + artFile);
3521   }
3522   return "";
3523 }
3524
3525 std::string CFileItem::GetFolderThumb(const std::string &folderJPG /* = "folder.jpg" */) const
3526 {
3527   std::string strFolder = m_strPath;
3528
3529   if (IsStack() ||
3530       URIUtils::IsInRAR(strFolder) ||
3531       URIUtils::IsInZIP(strFolder))
3532   {
3533     URIUtils::GetParentPath(m_strPath,strFolder);
3534   }
3535
3536   if (IsMultiPath())
3537     strFolder = CMultiPathDirectory::GetFirstPath(m_strPath);
3538
3539   if (IsPlugin())
3540     return "";
3541
3542   return URIUtils::AddFileToFolder(strFolder, folderJPG);
3543 }
3544
3545 std::string CFileItem::GetMovieName(bool bUseFolderNames /* = false */) const
3546 {
3547   if (IsPlugin() && HasVideoInfoTag() && !GetVideoInfoTag()->m_strTitle.empty())
3548     return GetVideoInfoTag()->m_strTitle;
3549
3550   if (IsLabelPreformatted())
3551     return GetLabel();
3552
3553   if (m_pvrRecordingInfoTag)
3554     return m_pvrRecordingInfoTag->m_strTitle;
3555   else if (URIUtils::IsPVRRecording(m_strPath))
3556   {
3557     std::string title = CPVRRecording::GetTitleFromURL(m_strPath);
3558     if (!title.empty())
3559       return title;
3560   }
3561
3562   std::string strMovieName;
3563   if (URIUtils::IsStack(m_strPath))
3564     strMovieName = CStackDirectory::GetStackedTitlePath(m_strPath);
3565   else
3566     strMovieName = GetBaseMoviePath(bUseFolderNames);
3567
3568   URIUtils::RemoveSlashAtEnd(strMovieName);
3569
3570   return CURL::Decode(URIUtils::GetFileName(strMovieName));
3571 }
3572
3573 std::string CFileItem::GetBaseMoviePath(bool bUseFolderNames) const
3574 {
3575   std::string strMovieName = m_strPath;
3576
3577   if (IsMultiPath())
3578     strMovieName = CMultiPathDirectory::GetFirstPath(m_strPath);
3579
3580   if (IsOpticalMediaFile())
3581     return GetLocalMetadataPath();
3582
3583   if (bUseFolderNames &&
3584      (!m_bIsFolder || URIUtils::IsInArchive(m_strPath) ||
3585      (HasVideoInfoTag() && GetVideoInfoTag()->m_iDbId > 0 && !CMediaTypes::IsContainer(GetVideoInfoTag()->m_type))))
3586   {
3587     std::string name2(strMovieName);
3588     URIUtils::GetParentPath(name2,strMovieName);
3589     if (URIUtils::IsInArchive(m_strPath))
3590     {
3591       // Try to get archive itself, if empty take path before
3592       name2 = CURL(m_strPath).GetHostName();
3593       if (name2.empty())
3594         name2 = strMovieName;
3595
3596       URIUtils::GetParentPath(name2, strMovieName);
3597     }
3598
3599     // Remove trailing 'Disc n' path segment to get actual movie title
3600     strMovieName = CUtil::RemoveTrailingDiscNumberSegmentFromPath(strMovieName);
3601   }
3602
3603   return strMovieName;
3604 }
3605
3606 std::string CFileItem::GetLocalFanart() const
3607 {
3608   if (IsVideoDb())
3609   {
3610     if (!HasVideoInfoTag())
3611       return ""; // nothing can be done
3612     CFileItem dbItem(m_bIsFolder ? GetVideoInfoTag()->m_strPath : GetVideoInfoTag()->m_strFileNameAndPath, m_bIsFolder);
3613     return dbItem.GetLocalFanart();
3614   }
3615
3616   std::string strFile2;
3617   std::string strFile = m_strPath;
3618   if (IsStack())
3619   {
3620     std::string strPath;
3621     URIUtils::GetParentPath(m_strPath,strPath);
3622     CStackDirectory dir;
3623     std::string strPath2;
3624     strPath2 = dir.GetStackedTitlePath(strFile);
3625     strFile = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strPath2));
3626     CFileItem item(dir.GetFirstStackedFile(m_strPath),false);
3627     std::string strTBNFile(URIUtils::ReplaceExtension(item.GetTBNFile(), "-fanart"));
3628     strFile2 = URIUtils::AddFileToFolder(strPath, URIUtils::GetFileName(strTBNFile));
3629   }
3630   if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
3631   {
3632     std::string strPath = URIUtils::GetDirectory(strFile);
3633     std::string strParent;
3634     URIUtils::GetParentPath(strPath,strParent);
3635     strFile = URIUtils::AddFileToFolder(strParent, URIUtils::GetFileName(m_strPath));
3636   }
3637
3638   // no local fanart available for these
3639   if (IsInternetStream()
3640    || URIUtils::IsUPnP(strFile)
3641    || URIUtils::IsBluray(strFile)
3642    || IsLiveTV()
3643    || IsPlugin()
3644    || IsAddonsPath()
3645    || IsDVD()
3646    || (URIUtils::IsFTP(strFile) && !CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_bFTPThumbs)
3647    || m_strPath.empty())
3648     return "";
3649
3650   std::string strDir = URIUtils::GetDirectory(strFile);
3651
3652   if (strDir.empty())
3653     return "";
3654
3655   CFileItemList items;
3656   CDirectory::GetDirectory(strDir, items, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO);
3657   if (IsOpticalMediaFile())
3658   { // grab from the optical media parent folder as well
3659     CFileItemList moreItems;
3660     CDirectory::GetDirectory(GetLocalMetadataPath(), moreItems, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions(), DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO);
3661     items.Append(moreItems);
3662   }
3663
3664   std::vector<std::string> fanarts = { "fanart" };
3665
3666   strFile = URIUtils::ReplaceExtension(strFile, "-fanart");
3667   fanarts.insert(m_bIsFolder ? fanarts.end() : fanarts.begin(), URIUtils::GetFileName(strFile));
3668
3669   if (!strFile2.empty())
3670     fanarts.insert(m_bIsFolder ? fanarts.end() : fanarts.begin(), URIUtils::GetFileName(strFile2));
3671
3672   for (std::vector<std::string>::const_iterator i = fanarts.begin(); i != fanarts.end(); ++i)
3673   {
3674     for (int j = 0; j < items.Size(); j++)
3675     {
3676       std::string strCandidate = URIUtils::GetFileName(items[j]->m_strPath);
3677       URIUtils::RemoveExtension(strCandidate);
3678       std::string strFanart = *i;
3679       URIUtils::RemoveExtension(strFanart);
3680       if (StringUtils::EqualsNoCase(strCandidate, strFanart))
3681         return items[j]->m_strPath;
3682     }
3683   }
3684
3685   return "";
3686 }
3687
3688 std::string CFileItem::GetLocalMetadataPath() const
3689 {
3690   if (m_bIsFolder && !IsFileFolder())
3691     return m_strPath;
3692
3693   std::string parent(URIUtils::GetParentPath(m_strPath));
3694   std::string parentFolder(parent);
3695   URIUtils::RemoveSlashAtEnd(parentFolder);
3696   parentFolder = URIUtils::GetFileName(parentFolder);
3697   if (StringUtils::EqualsNoCase(parentFolder, "VIDEO_TS") || StringUtils::EqualsNoCase(parentFolder, "BDMV"))
3698   { // go back up another one
3699     parent = URIUtils::GetParentPath(parent);
3700   }
3701   return parent;
3702 }
3703
3704 bool CFileItem::LoadMusicTag()
3705 {
3706   // not audio
3707   if (!IsAudio())
3708     return false;
3709   // already loaded?
3710   if (HasMusicInfoTag() && m_musicInfoTag->Loaded())
3711     return true;
3712   // check db
3713   CMusicDatabase musicDatabase;
3714   if (musicDatabase.Open())
3715   {
3716     CSong song;
3717     if (musicDatabase.GetSongByFileName(m_strPath, song))
3718     {
3719       GetMusicInfoTag()->SetSong(song);
3720       return true;
3721     }
3722     musicDatabase.Close();
3723   }
3724   // load tag from file
3725   CLog::Log(LOGDEBUG, "{}: loading tag information for file: {}", __FUNCTION__, m_strPath);
3726   CMusicInfoTagLoaderFactory factory;
3727   std::unique_ptr<IMusicInfoTagLoader> pLoader (factory.CreateLoader(*this));
3728   if (pLoader)
3729   {
3730     if (pLoader->Load(m_strPath, *GetMusicInfoTag()))
3731       return true;
3732   }
3733   // no tag - try some other things
3734   if (IsCDDA())
3735   {
3736     // we have the tracknumber...
3737     int iTrack = GetMusicInfoTag()->GetTrackNumber();
3738     if (iTrack >= 1)
3739     {
3740       std::string strText = g_localizeStrings.Get(554); // "Track"
3741       if (!strText.empty() && strText[strText.size() - 1] != ' ')
3742         strText += " ";
3743       std::string strTrack = StringUtils::Format((strText + "{}"), iTrack);
3744       GetMusicInfoTag()->SetTitle(strTrack);
3745       GetMusicInfoTag()->SetLoaded(true);
3746       return true;
3747     }
3748   }
3749   else
3750   {
3751     std::string fileName = URIUtils::GetFileName(m_strPath);
3752     URIUtils::RemoveExtension(fileName);
3753     for (const std::string& fileFilter : CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_musicTagsFromFileFilters)
3754     {
3755       CLabelFormatter formatter(fileFilter, "");
3756       if (formatter.FillMusicTag(fileName, GetMusicInfoTag()))
3757       {
3758         GetMusicInfoTag()->SetLoaded(true);
3759         return true;
3760       }
3761     }
3762   }
3763   return false;
3764 }
3765
3766 bool CFileItem::LoadGameTag()
3767 {
3768   // Already loaded?
3769   if (HasGameInfoTag() && m_gameInfoTag->IsLoaded())
3770     return true;
3771
3772   //! @todo
3773   GetGameInfoTag();
3774
3775   m_gameInfoTag->SetLoaded(true);
3776
3777   return false;
3778 }
3779
3780 bool CFileItem::LoadDetails()
3781 {
3782   if (IsVideoDb())
3783   {
3784     if (HasVideoInfoTag())
3785       return true;
3786
3787     CVideoDatabase db;
3788     if (!db.Open())
3789     {
3790       CLog::LogF(LOGERROR, "Error opening video database");
3791       return false;
3792     }
3793
3794     VIDEODATABASEDIRECTORY::CQueryParams params;
3795     VIDEODATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(GetPath(), params);
3796
3797     bool ret{false};
3798     auto tag{std::make_unique<CVideoInfoTag>()};
3799     if (params.GetMovieId() >= 0)
3800       ret = db.GetMovieInfo(GetPath(), *tag, static_cast<int>(params.GetMovieId()),
3801                             static_cast<int>(params.GetVideoVersionId()));
3802     else if (params.GetMVideoId() >= 0)
3803       ret = db.GetMusicVideoInfo(GetPath(), *tag, static_cast<int>(params.GetMVideoId()));
3804     else if (params.GetEpisodeId() >= 0)
3805       ret = db.GetEpisodeInfo(GetPath(), *tag, static_cast<int>(params.GetEpisodeId()));
3806     else if (params.GetSetId() >= 0) // movie set
3807       ret = db.GetSetInfo(static_cast<int>(params.GetSetId()), *tag, this);
3808     else if (params.GetTvShowId() >= 0)
3809     {
3810       if (params.GetSeason() >= 0)
3811       {
3812         const int idSeason = db.GetSeasonId(static_cast<int>(params.GetTvShowId()),
3813                                             static_cast<int>(params.GetSeason()));
3814         if (idSeason >= 0)
3815           ret = db.GetSeasonInfo(idSeason, *tag, this);
3816       }
3817       else
3818         ret = db.GetTvShowInfo(GetPath(), *tag, static_cast<int>(params.GetTvShowId()), this);
3819     }
3820
3821     if (ret)
3822     {
3823       const CFileItem loadedItem{*tag};
3824       UpdateInfo(loadedItem);
3825     }
3826     return ret;
3827   }
3828
3829   if (IsPVR())
3830   {
3831     const std::shared_ptr<CFileItem> loadedItem{
3832         CServiceBroker::GetPVRManager().Get<PVR::GUI::Utils>().LoadItem(*this)};
3833     if (loadedItem)
3834     {
3835       UpdateInfo(*loadedItem);
3836       return true;
3837     }
3838     CLog::LogF(LOGERROR, "Error filling PVR item details (path={})", GetPath());
3839     return false;
3840   }
3841
3842   if (!IsPlayList() && IsVideo())
3843   {
3844     if (HasVideoInfoTag())
3845       return true;
3846
3847     CVideoDatabase db;
3848     if (!db.Open())
3849     {
3850       CLog::LogF(LOGERROR, "Error opening video database");
3851       return false;
3852     }
3853
3854     auto tag{std::make_unique<CVideoInfoTag>()};
3855     if (db.LoadVideoInfo(GetDynPath(), *tag))
3856     {
3857       const CFileItem loadedItem{*tag};
3858       UpdateInfo(loadedItem);
3859       return true;
3860     }
3861
3862     CLog::LogF(LOGERROR, "Error filling item details (path={})", GetPath());
3863     return false;
3864   }
3865
3866   if (IsPlayList() && IsType(".strm"))
3867   {
3868     const std::unique_ptr<PLAYLIST::CPlayList> playlist(PLAYLIST::CPlayListFactory::Create(*this));
3869     if (playlist)
3870     {
3871       if (playlist->Load(GetPath()) && playlist->size() == 1)
3872       {
3873         const auto item{(*playlist)[0]};
3874         if (item->IsVideo())
3875         {
3876           CVideoDatabase db;
3877           if (!db.Open())
3878           {
3879             CLog::LogF(LOGERROR, "Error opening video database");
3880             return false;
3881           }
3882
3883           CVideoInfoTag tag;
3884           if (db.LoadVideoInfo(GetDynPath(), tag))
3885           {
3886             UpdateInfo(*item);
3887             *GetVideoInfoTag() = tag;
3888             return true;
3889           }
3890         }
3891         else if (item->IsAudio())
3892         {
3893           if (item->LoadMusicTag())
3894           {
3895             UpdateInfo(*item);
3896             return true;
3897           }
3898         }
3899       }
3900     }
3901     CLog::LogF(LOGERROR, "Error loading strm file details (path={})", GetPath());
3902     return false;
3903   }
3904
3905   if (IsAudio())
3906   {
3907     return LoadMusicTag();
3908   }
3909
3910   if (IsMusicDb())
3911   {
3912     if (HasMusicInfoTag())
3913       return true;
3914
3915     CMusicDatabase db;
3916     if (!db.Open())
3917     {
3918       CLog::LogF(LOGERROR, "Error opening music database");
3919       return false;
3920     }
3921
3922     MUSICDATABASEDIRECTORY::CQueryParams params;
3923     MUSICDATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(GetPath(), params);
3924
3925     if (params.GetSongId() >= 0)
3926     {
3927       CSong song;
3928       if (db.GetSong(params.GetSongId(), song))
3929       {
3930         GetMusicInfoTag()->SetSong(song);
3931         return true;
3932       }
3933     }
3934     else if (params.GetAlbumId() >= 0)
3935     {
3936       m_bIsFolder = true;
3937       CAlbum album;
3938       if (db.GetAlbum(params.GetAlbumId(), album, false))
3939       {
3940         GetMusicInfoTag()->SetAlbum(album);
3941         return true;
3942       }
3943     }
3944     else if (params.GetArtistId() >= 0)
3945     {
3946       m_bIsFolder = true;
3947       CArtist artist;
3948       if (db.GetArtist(params.GetArtistId(), artist, false))
3949       {
3950         GetMusicInfoTag()->SetArtist(artist);
3951         return true;
3952       }
3953     }
3954     return false;
3955   }
3956
3957   //! @todo add support for other types on demand.
3958   CLog::LogF(LOGDEBUG, "Unsupported item type (path={})", GetPath());
3959   return false;
3960 }
3961
3962 void CFileItemList::Swap(unsigned int item1, unsigned int item2)
3963 {
3964   if (item1 != item2 && item1 < m_items.size() && item2 < m_items.size())
3965     std::swap(m_items[item1], m_items[item2]);
3966 }
3967
3968 bool CFileItemList::UpdateItem(const CFileItem *item)
3969 {
3970   if (!item)
3971     return false;
3972
3973   std::unique_lock<CCriticalSection> lock(m_lock);
3974   for (unsigned int i = 0; i < m_items.size(); i++)
3975   {
3976     CFileItemPtr pItem = m_items[i];
3977     if (pItem->IsSamePath(item))
3978     {
3979       pItem->UpdateInfo(*item);
3980       return true;
3981     }
3982   }
3983   return false;
3984 }
3985
3986 void CFileItemList::AddSortMethod(SortBy sortBy, int buttonLabel, const LABEL_MASKS &labelMasks, SortAttribute sortAttributes /* = SortAttributeNone */)
3987 {
3988   AddSortMethod(sortBy, sortAttributes, buttonLabel, labelMasks);
3989 }
3990
3991 void CFileItemList::AddSortMethod(SortBy sortBy, SortAttribute sortAttributes, int buttonLabel, const LABEL_MASKS &labelMasks)
3992 {
3993   SortDescription sorting;
3994   sorting.sortBy = sortBy;
3995   sorting.sortAttributes = sortAttributes;
3996
3997   AddSortMethod(sorting, buttonLabel, labelMasks);
3998 }
3999
4000 void CFileItemList::AddSortMethod(SortDescription sortDescription, int buttonLabel, const LABEL_MASKS &labelMasks)
4001 {
4002   GUIViewSortDetails sort;
4003   sort.m_sortDescription = sortDescription;
4004   sort.m_buttonLabel = buttonLabel;
4005   sort.m_labelMasks = labelMasks;
4006
4007   m_sortDetails.push_back(sort);
4008 }
4009
4010 void CFileItemList::SetReplaceListing(bool replace)
4011 {
4012   m_replaceListing = replace;
4013 }
4014
4015 void CFileItemList::ClearSortState()
4016 {
4017   m_sortDescription.sortBy = SortByNone;
4018   m_sortDescription.sortOrder = SortOrderNone;
4019   m_sortDescription.sortAttributes = SortAttributeNone;
4020 }
4021
4022 bool CFileItem::HasVideoInfoTag() const
4023 {
4024   // Note: CPVRRecording is derived from CVideoInfoTag
4025   return m_pvrRecordingInfoTag.get() != nullptr || m_videoInfoTag != nullptr;
4026 }
4027
4028 CVideoInfoTag* CFileItem::GetVideoInfoTag()
4029 {
4030   // Note: CPVRRecording is derived from CVideoInfoTag
4031   if (m_pvrRecordingInfoTag)
4032     return m_pvrRecordingInfoTag.get();
4033   else if (!m_videoInfoTag)
4034     m_videoInfoTag = new CVideoInfoTag;
4035
4036   return m_videoInfoTag;
4037 }
4038
4039 const CVideoInfoTag* CFileItem::GetVideoInfoTag() const
4040 {
4041   // Note: CPVRRecording is derived from CVideoInfoTag
4042   return m_pvrRecordingInfoTag ? m_pvrRecordingInfoTag.get() : m_videoInfoTag;
4043 }
4044
4045 CPictureInfoTag* CFileItem::GetPictureInfoTag()
4046 {
4047   if (!m_pictureInfoTag)
4048     m_pictureInfoTag = new CPictureInfoTag;
4049
4050   return m_pictureInfoTag;
4051 }
4052
4053 MUSIC_INFO::CMusicInfoTag* CFileItem::GetMusicInfoTag()
4054 {
4055   if (!m_musicInfoTag)
4056     m_musicInfoTag = new MUSIC_INFO::CMusicInfoTag;
4057
4058   return m_musicInfoTag;
4059 }
4060
4061 CGameInfoTag* CFileItem::GetGameInfoTag()
4062 {
4063   if (!m_gameInfoTag)
4064     m_gameInfoTag = new CGameInfoTag;
4065
4066   return m_gameInfoTag;
4067 }
4068
4069 bool CFileItem::HasPVRChannelInfoTag() const
4070 {
4071   return m_pvrChannelGroupMemberInfoTag && m_pvrChannelGroupMemberInfoTag->Channel() != nullptr;
4072 }
4073
4074 const std::shared_ptr<PVR::CPVRChannel> CFileItem::GetPVRChannelInfoTag() const
4075 {
4076   return m_pvrChannelGroupMemberInfoTag ? m_pvrChannelGroupMemberInfoTag->Channel()
4077                                         : std::shared_ptr<CPVRChannel>();
4078 }
4079
4080 std::string CFileItem::FindTrailer() const
4081 {
4082   std::string strFile2;
4083   std::string strFile = m_strPath;
4084   if (IsStack())
4085   {
4086     std::string strPath;
4087     URIUtils::GetParentPath(m_strPath,strPath);
4088     CStackDirectory dir;
4089     std::string strPath2;
4090     strPath2 = dir.GetStackedTitlePath(strFile);
4091     strFile = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(strPath2));
4092     CFileItem item(dir.GetFirstStackedFile(m_strPath),false);
4093     std::string strTBNFile(URIUtils::ReplaceExtension(item.GetTBNFile(), "-trailer"));
4094     strFile2 = URIUtils::AddFileToFolder(strPath,URIUtils::GetFileName(strTBNFile));
4095   }
4096   if (URIUtils::IsInRAR(strFile) || URIUtils::IsInZIP(strFile))
4097   {
4098     std::string strPath = URIUtils::GetDirectory(strFile);
4099     std::string strParent;
4100     URIUtils::GetParentPath(strPath,strParent);
4101     strFile = URIUtils::AddFileToFolder(strParent,URIUtils::GetFileName(m_strPath));
4102   }
4103
4104   // no local trailer available for these
4105   if (IsInternetStream()
4106    || URIUtils::IsUPnP(strFile)
4107    || URIUtils::IsBluray(strFile)
4108    || IsLiveTV()
4109    || IsPlugin()
4110    || IsDVD())
4111     return "";
4112
4113   std::string strDir = URIUtils::GetDirectory(strFile);
4114   CFileItemList items;
4115   CDirectory::GetDirectory(strDir, items, CServiceBroker::GetFileExtensionProvider().GetVideoExtensions(), DIR_FLAG_READ_CACHE | DIR_FLAG_NO_FILE_INFO | DIR_FLAG_NO_FILE_DIRS);
4116   URIUtils::RemoveExtension(strFile);
4117   strFile += "-trailer";
4118   std::string strFile3 = URIUtils::AddFileToFolder(strDir, "movie-trailer");
4119
4120   // Precompile our REs
4121   VECCREGEXP matchRegExps;
4122   CRegExp tmpRegExp(true, CRegExp::autoUtf8);
4123   const std::vector<std::string>& strMatchRegExps = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_trailerMatchRegExps;
4124
4125   std::vector<std::string>::const_iterator strRegExp = strMatchRegExps.begin();
4126   while (strRegExp != strMatchRegExps.end())
4127   {
4128     if (tmpRegExp.RegComp(*strRegExp))
4129     {
4130       matchRegExps.push_back(tmpRegExp);
4131     }
4132     ++strRegExp;
4133   }
4134
4135   std::string strTrailer;
4136   for (int i = 0; i < items.Size(); i++)
4137   {
4138     std::string strCandidate = items[i]->m_strPath;
4139     URIUtils::RemoveExtension(strCandidate);
4140     if (StringUtils::EqualsNoCase(strCandidate, strFile) ||
4141         StringUtils::EqualsNoCase(strCandidate, strFile2) ||
4142         StringUtils::EqualsNoCase(strCandidate, strFile3))
4143     {
4144       strTrailer = items[i]->m_strPath;
4145       break;
4146     }
4147     else
4148     {
4149       VECCREGEXP::iterator expr = matchRegExps.begin();
4150
4151       while (expr != matchRegExps.end())
4152       {
4153         if (expr->RegFind(strCandidate) != -1)
4154         {
4155           strTrailer = items[i]->m_strPath;
4156           i = items.Size();
4157           break;
4158         }
4159         ++expr;
4160       }
4161     }
4162   }
4163
4164   return strTrailer;
4165 }
4166
4167 VideoDbContentType CFileItem::GetVideoContentType() const
4168 {
4169   VideoDbContentType type = VideoDbContentType::MOVIES;
4170   if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeTvShow)
4171     type = VideoDbContentType::TVSHOWS;
4172   if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeEpisode)
4173     return VideoDbContentType::EPISODES;
4174   if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeMusicVideo)
4175     return VideoDbContentType::MUSICVIDEOS;
4176   if (HasVideoInfoTag() && GetVideoInfoTag()->m_type == MediaTypeAlbum)
4177     return VideoDbContentType::MUSICALBUMS;
4178
4179   CVideoDatabaseDirectory dir;
4180   VIDEODATABASEDIRECTORY::CQueryParams params;
4181   dir.GetQueryParams(m_strPath, params);
4182   if (params.GetSetId() != -1 && params.GetMovieId() == -1) // movie set
4183     return VideoDbContentType::MOVIE_SETS;
4184
4185   return type;
4186 }
4187
4188 CFileItem CFileItem::GetItemToPlay() const
4189 {
4190   if (HasEPGInfoTag())
4191   {
4192     const std::shared_ptr<CPVRChannelGroupMember> groupMember =
4193         CServiceBroker::GetPVRManager().Get<PVR::GUI::Channels>().GetChannelGroupMember(*this);
4194     if (groupMember)
4195       return CFileItem(groupMember);
4196   }
4197   return *this;
4198 }
4199
4200 CBookmark CFileItem::GetResumePoint() const
4201 {
4202   if (HasVideoInfoTag())
4203     return GetVideoInfoTag()->GetResumePoint();
4204   return CBookmark();
4205 }
4206
4207 bool CFileItem::IsResumePointSet() const
4208 {
4209   return GetResumePoint().IsSet();
4210 }
4211
4212 double CFileItem::GetCurrentResumeTime() const
4213 {
4214   return lrint(GetResumePoint().timeInSeconds);
4215 }
4216
4217 bool CFileItem::GetCurrentResumeTimeAndPartNumber(int64_t& startOffset, int& partNumber) const
4218 {
4219   CBookmark resumePoint(GetResumePoint());
4220   if (resumePoint.IsSet())
4221   {
4222     startOffset = llrint(resumePoint.timeInSeconds);
4223     partNumber = resumePoint.partNumber;
4224     return true;
4225   }
4226   return false;
4227 }
4228
4229 bool CFileItem::IsResumable() const
4230 {
4231   if (m_bIsFolder)
4232   {
4233     int64_t watched = 0;
4234     int64_t inprogress = 0;
4235     int64_t total = 0;
4236     if (HasProperty("inprogressepisodes"))
4237     {
4238       // show/season
4239       watched = GetProperty("watchedepisodes").asInteger();
4240       inprogress = GetProperty("inprogressepisodes").asInteger();
4241       total = GetProperty("totalepisodes").asInteger();
4242     }
4243     else if (HasProperty("inprogress"))
4244     {
4245       // movie set
4246       watched = GetProperty("watched").asInteger();
4247       inprogress = GetProperty("inprogress").asInteger();
4248       total = GetProperty("total").asInteger();
4249     }
4250
4251     return ((total != watched) && (inprogress > 0 || watched != 0));
4252   }
4253   else
4254   {
4255     return HasVideoInfoTag() && GetVideoInfoTag()->GetResumePoint().IsPartWay();
4256   }
4257 }
4258
4259 bool CFileItem::HasVideoVersions() const
4260 {
4261   if (HasVideoInfoTag())
4262   {
4263     return GetVideoInfoTag()->HasVideoVersions();
4264   }
4265   return false;
4266 }
4267
4268 bool CFileItem::HasVideoExtras() const
4269 {
4270   if (HasVideoInfoTag())
4271   {
4272     return GetVideoInfoTag()->HasVideoExtras();
4273   }
4274   return false;
4275 }