xbmc/video/VideoUtils.cpp

   1 /*
   2  *  Copyright (C) 2022 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 "VideoUtils.h"
  10
  11 #include "FileItem.h"
  12 #include "FileItemList.h"
  13 #include "ServiceBroker.h"
  14 #include "Util.h"
  15 #include "filesystem/Directory.h"
  16 #include "filesystem/VideoDatabaseDirectory/QueryParams.h"
  17 #include "playlists/PlayListFileItemClassify.h"
  18 #include "settings/SettingUtils.h"
  19 #include "settings/Settings.h"
  20 #include "settings/SettingsComponent.h"
  21 #include "settings/lib/Setting.h"
  22 #include "utils/FileUtils.h"
  23 #include "utils/URIUtils.h"
  24 #include "utils/log.h"
  25 #include "video/VideoDatabase.h"
  26 #include "video/VideoFileItemClassify.h"
  27 #include "video/VideoInfoTag.h"
  28
  29 #include <algorithm>
  30 #include <array>
  31 #include <cstdint>
  32 #include <vector>
  33
  34 using namespace KODI;
  35
  36 namespace
  37 {
  38 KODI::VIDEO::UTILS::ResumeInformation GetFolderItemResumeInformation(const CFileItem& item)
  39 {
  40   if (!item.m_bIsFolder)
  41     return {};
  42
  43   CFileItem folderItem(item);
  44   if ((!folderItem.HasProperty("inprogressepisodes") || // season/show
  45        (folderItem.GetProperty("inprogressepisodes").asInteger() == 0)) &&
  46       (!folderItem.HasProperty("inprogress") || // movie set
  47        (folderItem.GetProperty("inprogress").asInteger() == 0)))
  48   {
  49     CVideoDatabase db;
  50     if (db.Open())
  51     {
  52       if (!folderItem.HasProperty("inprogressepisodes") && !folderItem.HasProperty("inprogress"))
  53       {
  54         XFILE::VIDEODATABASEDIRECTORY::CQueryParams params;
  55         XFILE::VIDEODATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(item.GetPath(), params);
  56
  57         if (params.GetTvShowId() >= 0)
  58         {
  59           if (params.GetSeason() >= 0)
  60           {
  61             const int idSeason = db.GetSeasonId(static_cast<int>(params.GetTvShowId()),
  62                                                 static_cast<int>(params.GetSeason()));
  63             if (idSeason >= 0)
  64             {
  65               CVideoInfoTag details;
  66               db.GetSeasonInfo(idSeason, details, &folderItem);
  67             }
  68           }
  69           else
  70           {
  71             CVideoInfoTag details;
  72             db.GetTvShowInfo(item.GetPath(), details, static_cast<int>(params.GetTvShowId()),
  73                              &folderItem);
  74           }
  75         }
  76         else if (params.GetSetId() >= 0)
  77         {
  78           CVideoInfoTag details;
  79           db.GetSetInfo(static_cast<int>(params.GetSetId()), details, &folderItem);
  80         }
  81       }
  82       db.Close();
  83     }
  84   }
  85
  86   if (folderItem.IsResumable())
  87   {
  88     KODI::VIDEO::UTILS::ResumeInformation resumeInfo;
  89     resumeInfo.isResumable = true;
  90     return resumeInfo;
  91   }
  92
  93   return {};
  94 }
  95
  96 KODI::VIDEO::UTILS::ResumeInformation GetNonFolderItemResumeInformation(const CFileItem& item)
  97 {
  98   // do not resume nfo files
  99   if (item.IsNFO())
 100     return {};
 101
 102   // do not resume playlists, except strm files
 103   if (!item.IsType(".strm") && PLAYLIST::IsPlayList(item))
 104     return {};
 105
 106   // do not resume Live TV and 'deleted' items (e.g. trashed pvr recordings)
 107   if (item.IsLiveTV() || item.IsDeleted())
 108     return {};
 109
 110   KODI::VIDEO::UTILS::ResumeInformation resumeInfo;
 111
 112   if (item.GetCurrentResumeTimeAndPartNumber(resumeInfo.startOffset, resumeInfo.partNumber))
 113   {
 114     if (resumeInfo.startOffset > 0)
 115     {
 116       resumeInfo.startOffset = CUtil::ConvertSecsToMilliSecs(resumeInfo.startOffset);
 117       resumeInfo.isResumable = true;
 118     }
 119   }
 120   else
 121   {
 122     // Obtain the resume bookmark from video db...
 123
 124     CVideoDatabase db;
 125     if (!db.Open())
 126     {
 127       CLog::LogF(LOGERROR, "Cannot open VideoDatabase");
 128       return {};
 129     }
 130
 131     std::string path = item.GetPath();
 132     if (VIDEO::IsVideoDb(item) || item.IsDVD())
 133     {
 134       if (item.HasVideoInfoTag())
 135       {
 136         path = item.GetVideoInfoTag()->m_strFileNameAndPath;
 137       }
 138       else if (VIDEO::IsVideoDb(item))
 139       {
 140         // Obtain path+filename from video db
 141         XFILE::VIDEODATABASEDIRECTORY::CQueryParams params;
 142         XFILE::VIDEODATABASEDIRECTORY::CDirectoryNode::GetDatabaseInfo(item.GetPath(), params);
 143
 144         long id = -1;
 145         VideoDbContentType content_type;
 146         if ((id = params.GetMovieId()) >= 0)
 147           content_type = VideoDbContentType::MOVIES;
 148         else if ((id = params.GetEpisodeId()) >= 0)
 149           content_type = VideoDbContentType::EPISODES;
 150         else if ((id = params.GetMVideoId()) >= 0)
 151           content_type = VideoDbContentType::MUSICVIDEOS;
 152         else
 153         {
 154           CLog::LogF(LOGERROR, "Cannot obtain video content type");
 155           db.Close();
 156           return {};
 157         }
 158
 159         db.GetFilePathById(static_cast<int>(id), path, content_type);
 160       }
 161       else
 162       {
 163         // DVD
 164         CLog::LogF(LOGERROR, "Cannot obtain bookmark for DVD");
 165         db.Close();
 166         return {};
 167       }
 168     }
 169
 170     CBookmark bookmark;
 171     db.GetResumeBookMark(path, bookmark);
 172     db.Close();
 173
 174     if (bookmark.IsSet())
 175     {
 176       resumeInfo.isResumable = bookmark.IsPartWay();
 177       resumeInfo.startOffset = CUtil::ConvertSecsToMilliSecs(bookmark.timeInSeconds);
 178       resumeInfo.partNumber = static_cast<int>(bookmark.partNumber);
 179     }
 180   }
 181   return resumeInfo;
 182 }
 183
 184 } // unnamed namespace
 185
 186 namespace KODI::VIDEO::UTILS
 187 {
 188 std::string GetOpticalMediaPath(const CFileItem& item)
 189 {
 190   auto exists = [&item](const std::string& file)
 191   {
 192     const std::string path = URIUtils::AddFileToFolder(item.GetPath(), file);
 193     return CFileUtils::Exists(path);
 194   };
 195
 196   using namespace std::string_literals;
 197   const auto files = std::array{
 198       "VIDEO_TS.IFO"s,    "VIDEO_TS/VIDEO_TS.IFO"s,
 199 #ifdef HAVE_LIBBLURAY
 200       "index.bdmv"s,      "INDEX.BDM"s,
 201       "BDMV/index.bdmv"s, "BDMV/INDEX.BDM"s,
 202 #endif
 203   };
 204
 205   const auto it = std::find_if(files.begin(), files.end(), exists);
 206   return it != files.end() ? URIUtils::AddFileToFolder(item.GetPath(), *it) : std::string{};
 207 }
 208
 209 bool IsAutoPlayNextItem(const CFileItem& item)
 210 {
 211   if (!item.HasVideoInfoTag())
 212     return false;
 213
 214   return IsAutoPlayNextItem(item.GetVideoInfoTag()->m_type);
 215 }
 216
 217 bool IsAutoPlayNextItem(const std::string& content)
 218 {
 219   int settingValue = CSettings::SETTING_AUTOPLAYNEXT_UNCATEGORIZED;
 220   if (content == MediaTypeMovie || content == MediaTypeMovies ||
 221       content == MediaTypeVideoCollections)
 222     settingValue = CSettings::SETTING_AUTOPLAYNEXT_MOVIES;
 223   else if (content == MediaTypeEpisode || content == MediaTypeSeasons ||
 224            content == MediaTypeEpisodes)
 225     settingValue = CSettings::SETTING_AUTOPLAYNEXT_EPISODES;
 226   else if (content == MediaTypeMusicVideo || content == MediaTypeMusicVideos)
 227     settingValue = CSettings::SETTING_AUTOPLAYNEXT_MUSICVIDEOS;
 228   else if (content == MediaTypeTvShow || content == MediaTypeTvShows)
 229     settingValue = CSettings::SETTING_AUTOPLAYNEXT_TVSHOWS;
 230
 231   const auto setting = std::dynamic_pointer_cast<CSettingList>(
 232       CServiceBroker::GetSettingsComponent()->GetSettings()->GetSetting(
 233           CSettings::SETTING_VIDEOPLAYER_AUTOPLAYNEXTITEM));
 234
 235   return setting && CSettingUtils::FindIntInList(setting, settingValue);
 236 }
 237
 238 ResumeInformation GetItemResumeInformation(const CFileItem& item)
 239 {
 240   ResumeInformation info = GetNonFolderItemResumeInformation(item);
 241   if (info.isResumable)
 242     return info;
 243
 244   return GetFolderItemResumeInformation(item);
 245 }
 246
 247 ResumeInformation GetStackPartResumeInformation(const CFileItem& item, unsigned int partNumber)
 248 {
 249   ResumeInformation resumeInfo;
 250
 251   if (item.IsStack())
 252   {
 253     const std::string& path = item.GetDynPath();
 254     if (URIUtils::IsDiscImageStack(path))
 255     {
 256       // disc image stack
 257       CFileItemList parts;
 258       XFILE::CDirectory::GetDirectory(path, parts, "", XFILE::DIR_FLAG_DEFAULTS);
 259
 260       resumeInfo = GetItemResumeInformation(*parts[partNumber - 1]);
 261       resumeInfo.partNumber = partNumber;
 262     }
 263     else
 264     {
 265       // video file stack
 266       CVideoDatabase db;
 267       if (!db.Open())
 268       {
 269         CLog::LogF(LOGERROR, "Cannot open VideoDatabase");
 270         return {};
 271       }
 272
 273       std::vector<uint64_t> times;
 274       if (db.GetStackTimes(path, times))
 275       {
 276         resumeInfo.startOffset = times[partNumber - 1];
 277         resumeInfo.isResumable = (resumeInfo.startOffset > 0);
 278       }
 279       resumeInfo.partNumber = partNumber;
 280     }
 281   }
 282   return resumeInfo;
 283 }
 284
 285 } // namespace KODI::VIDEO::UTILS