xbmc/playlists/PlayList.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "PlayList.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "PlayListFactory.h"
  14 #include "ServiceBroker.h"
  15 #include "filesystem/File.h"
  16 #include "interfaces/AnnouncementManager.h"
  17 #include "music/MusicFileItemClassify.h"
  18 #include "music/tags/MusicInfoTag.h"
  19 #include "utils/Random.h"
  20 #include "utils/StringUtils.h"
  21 #include "utils/URIUtils.h"
  22 #include "utils/Variant.h"
  23 #include "utils/log.h"
  24
  25 #include <algorithm>
  26 #include <cassert>
  27 #include <iostream>
  28 #include <sstream>
  29 #include <string>
  30 #include <utility>
  31 #include <vector>
  32
  33 using namespace MUSIC_INFO;
  34 using namespace XFILE;
  35
  36 namespace KODI::PLAYLIST
  37 {
  38
  39 CPlayList::CPlayList(Id id /* = PLAYLIST::TYPE_NONE */) : m_id(id)
  40 {
  41   m_iPlayableItems = -1;
  42   m_bShuffled = false;
  43   m_bWasPlayed = false;
  44 }
  45
  46 void CPlayList::AnnounceRemove(int pos)
  47 {
  48   if (m_id == Id::TYPE_NONE)
  49     return;
  50
  51   CVariant data;
  52   data["playlistid"] = static_cast<int>(m_id);
  53   data["position"] = pos;
  54   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Playlist, "OnRemove", data);
  55 }
  56
  57 void CPlayList::AnnounceClear()
  58 {
  59   if (m_id == Id::TYPE_NONE)
  60     return;
  61
  62   CVariant data;
  63   data["playlistid"] = static_cast<int>(m_id);
  64   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Playlist, "OnClear", data);
  65 }
  66
  67 void CPlayList::AnnounceAdd(const std::shared_ptr<CFileItem>& item, int pos)
  68 {
  69   if (m_id == Id::TYPE_NONE)
  70     return;
  71
  72   CVariant data;
  73   data["playlistid"] = static_cast<int>(m_id);
  74   data["position"] = pos;
  75   CServiceBroker::GetAnnouncementManager()->Announce(ANNOUNCEMENT::Playlist, "OnAdd", item, data);
  76 }
  77
  78 void CPlayList::Add(const std::shared_ptr<CFileItem>& item, int iPosition, int iOrder)
  79 {
  80   int iOldSize = size();
  81   if (iPosition < 0 || iPosition >= iOldSize)
  82     iPosition = iOldSize;
  83   if (iOrder < 0 || iOrder >= iOldSize)
  84     item->m_iprogramCount = iOldSize;
  85   else
  86     item->m_iprogramCount = iOrder;
  87
  88   // increment the playable counter
  89   item->ClearProperty("unplayable");
  90   if (m_iPlayableItems < 0)
  91     m_iPlayableItems = 1;
  92   else
  93     m_iPlayableItems++;
  94
  95   // set 'IsPlayable' property - needed for properly handling plugin:// URLs
  96   item->SetProperty("IsPlayable", true);
  97
  98   //CLog::Log(LOGDEBUG,"{} item:({:02}/{:02})[{}]", __FUNCTION__, iPosition, item->m_iprogramCount, item->GetPath());
  99   if (iPosition == iOldSize)
 100     m_vecItems.push_back(item);
 101   else
 102   {
 103     ivecItems it = m_vecItems.begin() + iPosition;
 104     m_vecItems.insert(it, 1, item);
 105     // correct any duplicate order values
 106     if (iOrder < iOldSize)
 107       IncrementOrder(iPosition + 1, iOrder);
 108   }
 109   AnnounceAdd(item, iPosition);
 110 }
 111
 112 void CPlayList::Add(const std::shared_ptr<CFileItem>& item)
 113 {
 114   Add(item, -1, -1);
 115 }
 116
 117 void CPlayList::Add(const CPlayList& playlist)
 118 {
 119   for (int i = 0; i < playlist.size(); i++)
 120     Add(playlist[i], -1, -1);
 121 }
 122
 123 void CPlayList::Add(const CFileItemList& items)
 124 {
 125   for (int i = 0; i < items.Size(); i++)
 126     Add(items[i]);
 127 }
 128
 129 void CPlayList::Insert(const CPlayList& playlist, int iPosition /* = -1 */)
 130 {
 131   // out of bounds so just add to the end
 132   int iSize = size();
 133   if (iPosition < 0 || iPosition >= iSize)
 134   {
 135     Add(playlist);
 136     return;
 137   }
 138   for (int i = 0; i < playlist.size(); i++)
 139   {
 140     int iPos = iPosition + i;
 141     Add(playlist[i], iPos, iPos);
 142   }
 143 }
 144
 145 void CPlayList::Insert(const CFileItemList& items, int iPosition /* = -1 */)
 146 {
 147   // out of bounds so just add to the end
 148   int iSize = size();
 149   if (iPosition < 0 || iPosition >= iSize)
 150   {
 151     Add(items);
 152     return;
 153   }
 154   for (int i = 0; i < items.Size(); i++)
 155   {
 156     Add(items[i], iPosition + i, iPosition + i);
 157   }
 158 }
 159
 160 void CPlayList::Insert(const std::shared_ptr<CFileItem>& item, int iPosition /* = -1 */)
 161 {
 162   // out of bounds so just add to the end
 163   int iSize = size();
 164   if (iPosition < 0 || iPosition >= iSize)
 165   {
 166     Add(item);
 167     return;
 168   }
 169   Add(item, iPosition, iPosition);
 170 }
 171
 172 void CPlayList::DecrementOrder(int iOrder)
 173 {
 174   if (iOrder < 0) return;
 175
 176   // it was the last item so do nothing
 177   if (iOrder == size()) return;
 178
 179   // fix all items with an order greater than the removed iOrder
 180   ivecItems it;
 181   it = m_vecItems.begin();
 182   while (it != m_vecItems.end())
 183   {
 184     CFileItemPtr item = *it;
 185     if (item->m_iprogramCount > iOrder)
 186     {
 187       //CLog::Log(LOGDEBUG,"{} fixing item at order {}", __FUNCTION__, item->m_iprogramCount);
 188       item->m_iprogramCount--;
 189     }
 190     ++it;
 191   }
 192 }
 193
 194 void CPlayList::IncrementOrder(int iPosition, int iOrder)
 195 {
 196   if (iOrder < 0) return;
 197
 198   // fix all items with an order equal or greater to the added iOrder at iPos
 199   ivecItems it;
 200   it = m_vecItems.begin() + iPosition;
 201   while (it != m_vecItems.end())
 202   {
 203     CFileItemPtr item = *it;
 204     if (item->m_iprogramCount >= iOrder)
 205     {
 206       //CLog::Log(LOGDEBUG,"{} fixing item at order {}", __FUNCTION__, item->m_iprogramCount);
 207       item->m_iprogramCount++;
 208     }
 209     ++it;
 210   }
 211 }
 212
 213 void CPlayList::Clear()
 214 {
 215   bool announce = false;
 216   if (!m_vecItems.empty())
 217   {
 218     m_vecItems.erase(m_vecItems.begin(), m_vecItems.end());
 219     announce = true;
 220   }
 221   m_strPlayListName = "";
 222   m_iPlayableItems = -1;
 223   m_bWasPlayed = false;
 224
 225   if (announce)
 226     AnnounceClear();
 227 }
 228
 229 int CPlayList::size() const
 230 {
 231   return (int)m_vecItems.size();
 232 }
 233
 234 const std::shared_ptr<CFileItem> CPlayList::operator[](int iItem) const
 235 {
 236   if (iItem < 0 || iItem >= size())
 237   {
 238     assert(false);
 239     CLog::Log(LOGERROR, "Error trying to retrieve an item that's out of range");
 240     return CFileItemPtr();
 241   }
 242   return m_vecItems[iItem];
 243 }
 244
 245 std::shared_ptr<CFileItem> CPlayList::operator[](int iItem)
 246 {
 247   if (iItem < 0 || iItem >= size())
 248   {
 249     assert(false);
 250     CLog::Log(LOGERROR, "Error trying to retrieve an item that's out of range");
 251     return CFileItemPtr();
 252   }
 253   return m_vecItems[iItem];
 254 }
 255
 256 void CPlayList::Shuffle(int iPosition)
 257 {
 258   if (size() == 0)
 259     // nothing to shuffle, just set the flag for later
 260     m_bShuffled = true;
 261   else
 262   {
 263     if (iPosition >= size())
 264       return;
 265     if (iPosition < 0)
 266       iPosition = 0;
 267     CLog::Log(LOGDEBUG, "{} shuffling at pos:{}", __FUNCTION__, iPosition);
 268
 269     ivecItems it = m_vecItems.begin() + iPosition;
 270     KODI::UTILS::RandomShuffle(it, m_vecItems.end());
 271
 272     // the list is now shuffled!
 273     m_bShuffled = true;
 274   }
 275 }
 276
 277 struct SSortPlayListItem
 278 {
 279   static bool PlaylistSort(const CFileItemPtr &left, const CFileItemPtr &right)
 280   {
 281     return (left->m_iprogramCount < right->m_iprogramCount);
 282   }
 283 };
 284
 285 void CPlayList::UnShuffle()
 286 {
 287   std::sort(m_vecItems.begin(), m_vecItems.end(), SSortPlayListItem::PlaylistSort);
 288   // the list is now unshuffled!
 289   m_bShuffled = false;
 290 }
 291
 292 const std::string& CPlayList::GetName() const
 293 {
 294   return m_strPlayListName;
 295 }
 296
 297 void CPlayList::Remove(const std::string& strFileName)
 298 {
 299   int iOrder = -1;
 300   int position = 0;
 301   ivecItems it;
 302   it = m_vecItems.begin();
 303   while (it != m_vecItems.end() )
 304   {
 305     CFileItemPtr item = *it;
 306     if (item->GetPath() == strFileName)
 307     {
 308       iOrder = item->m_iprogramCount;
 309       it = m_vecItems.erase(it);
 310       AnnounceRemove(position);
 311       //CLog::Log(LOGDEBUG,"PLAYLIST, removing item at order {}", iPos);
 312     }
 313     else
 314     {
 315       ++position;
 316       ++it;
 317     }
 318   }
 319   DecrementOrder(iOrder);
 320 }
 321
 322 int CPlayList::FindOrder(int iOrder) const
 323 {
 324   for (int i = 0; i < size(); i++)
 325   {
 326     if (m_vecItems[i]->m_iprogramCount == iOrder)
 327       return i;
 328   }
 329   return -1;
 330 }
 331
 332 // remove item from playlist by position
 333 void CPlayList::Remove(int position)
 334 {
 335   int iOrder = -1;
 336   if (position >= 0 && position < (int)m_vecItems.size())
 337   {
 338     iOrder = m_vecItems[position]->m_iprogramCount;
 339     m_vecItems.erase(m_vecItems.begin() + position);
 340   }
 341   DecrementOrder(iOrder);
 342
 343   AnnounceRemove(position);
 344 }
 345
 346 int CPlayList::RemoveDVDItems()
 347 {
 348   std::vector <std::string> vecFilenames;
 349
 350   // Collect playlist items from DVD share
 351   ivecItems it;
 352   it = m_vecItems.begin();
 353   while (it != m_vecItems.end() )
 354   {
 355     CFileItemPtr item = *it;
 356     if (MUSIC::IsCDDA(*item) || item->IsOnDVD())
 357     {
 358       vecFilenames.push_back( item->GetPath() );
 359     }
 360     ++it;
 361   }
 362
 363   // Delete them from playlist
 364   int nFileCount = vecFilenames.size();
 365   if ( nFileCount )
 366   {
 367     std::vector <std::string>::iterator it;
 368     it = vecFilenames.begin();
 369     while (it != vecFilenames.end() )
 370     {
 371       std::string& strFilename = *it;
 372       Remove( strFilename );
 373       ++it;
 374     }
 375     vecFilenames.erase( vecFilenames.begin(), vecFilenames.end() );
 376   }
 377   return nFileCount;
 378 }
 379
 380 bool CPlayList::Swap(int position1, int position2)
 381 {
 382   if (
 383     (position1 < 0) ||
 384     (position2 < 0) ||
 385     (position1 >= size()) ||
 386     (position2 >= size())
 387   )
 388   {
 389     return false;
 390   }
 391
 392   if (!IsShuffled())
 393   {
 394     // swap the ordinals before swapping the items!
 395     //CLog::Log(LOGDEBUG,"PLAYLIST swapping items at orders ({}, {})",m_vecItems[position1]->m_iprogramCount,m_vecItems[position2]->m_iprogramCount);
 396     std::swap(m_vecItems[position1]->m_iprogramCount, m_vecItems[position2]->m_iprogramCount);
 397   }
 398
 399   // swap the items
 400   std::swap(m_vecItems[position1], m_vecItems[position2]);
 401   return true;
 402 }
 403
 404 void CPlayList::SetUnPlayable(int iItem)
 405 {
 406   if (iItem < 0 || iItem >= size())
 407   {
 408     CLog::Log(LOGWARNING, "Attempt to set unplayable index {}", iItem);
 409     return;
 410   }
 411
 412   CFileItemPtr item = m_vecItems[iItem];
 413   if (!item->GetProperty("unplayable").asBoolean())
 414   {
 415     item->SetProperty("unplayable", true);
 416     m_iPlayableItems--;
 417   }
 418 }
 419
 420
 421 bool CPlayList::Load(const std::string& strFileName)
 422 {
 423   Clear();
 424   m_strBasePath = URIUtils::GetDirectory(strFileName);
 425
 426   CFileStream file;
 427   if (!file.Open(strFileName))
 428     return false;
 429
 430   if (file.GetLength() > 1024*1024)
 431   {
 432     CLog::Log(LOGWARNING, "{} - File is larger than 1 MB, most likely not a playlist",
 433               __FUNCTION__);
 434     return false;
 435   }
 436
 437   return LoadData(file);
 438 }
 439
 440 bool CPlayList::LoadData(std::istream &stream)
 441 {
 442   // try to read as a string
 443   std::ostringstream ostr;
 444   ostr << stream.rdbuf();
 445   return LoadData(ostr.str());
 446 }
 447
 448 bool CPlayList::LoadData(const std::string& strData)
 449 {
 450   return false;
 451 }
 452
 453
 454 bool CPlayList::Expand(int position)
 455 {
 456   CFileItemPtr item = m_vecItems[position];
 457   std::unique_ptr<CPlayList> playlist (CPlayListFactory::Create(*item.get()));
 458   if (playlist == nullptr)
 459     return false;
 460
 461   std::string path = item->GetDynPath();
 462
 463   if (!playlist->Load(path))
 464     return false;
 465
 466   // remove any item that points back to itself
 467   for (int i = 0;i<playlist->size();i++)
 468   {
 469     if (StringUtils::EqualsNoCase((*playlist)[i]->GetPath(), path))
 470     {
 471       playlist->Remove(i);
 472       i--;
 473     }
 474   }
 475
 476   // @todo
 477   // never change original path (id) of a file item
 478   for (int i = 0;i<playlist->size();i++)
 479   {
 480     (*playlist)[i]->SetDynPath((*playlist)[i]->GetPath());
 481     (*playlist)[i]->SetPath(item->GetDynPath());
 482     (*playlist)[i]->SetStartOffset(item->GetStartOffset());
 483   }
 484
 485   if (playlist->size() <= 0)
 486     return false;
 487
 488   Remove(position);
 489   Insert(*playlist, position);
 490   return true;
 491 }
 492
 493 void CPlayList::UpdateItem(const CFileItem *item)
 494 {
 495   if (!item) return;
 496
 497   for (ivecItems it = m_vecItems.begin(); it != m_vecItems.end(); ++it)
 498   {
 499     CFileItemPtr playlistItem = *it;
 500     if (playlistItem->IsSamePath(item))
 501     {
 502       std::string temp = playlistItem->GetPath(); // save path, it may have been altered
 503       *playlistItem = *item;
 504       playlistItem->SetPath(temp);
 505       break;
 506     }
 507   }
 508 }
 509
 510 const std::string& CPlayList::ResolveURL(const std::shared_ptr<CFileItem>& item) const
 511 {
 512   if (MUSIC::IsMusicDb(*item) && item->HasMusicInfoTag())
 513     return item->GetMusicInfoTag()->GetURL();
 514   else
 515     return item->GetDynPath();
 516 }
 517
 518 } // namespace KODI::PLAYLIST