xbmc/ApplicationStackHelper.cpp

   1 /*
   2  *  Copyright (C) 2017-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 "ApplicationStackHelper.h"
  10
  11 #include "ApplicationPlayer.h"
  12 #include "Util.h"
  13 #include "cores/VideoPlayer/DVDFileInfo.h"
  14 #include "filesystem/StackDirectory.h"
  15 #include "utils/URIUtils.h"
  16 #include "utils/log.h"
  17 #include "video/VideoDatabase.h"
  18
  19 #include <utility>
  20
  21 using namespace XFILE;
  22
  23 CApplicationStackHelper::CApplicationStackHelper(void)
  24   : m_currentStack(new CFileItemList)
  25 {
  26 }
  27
  28 void CApplicationStackHelper::Clear()
  29 {
  30   m_currentStackPosition = 0;
  31   m_currentStack->Clear();
  32 }
  33
  34 void CApplicationStackHelper::OnPlayBackStarted(const CFileItem& item)
  35 {
  36   std::unique_lock<CCriticalSection> lock(m_critSection);
  37
  38   // time to clean up stack map
  39   if (!HasRegisteredStack(item))
  40     m_stackmap.clear();
  41   else
  42   {
  43     auto stack = GetRegisteredStack(item);
  44     Stackmap::iterator itr = m_stackmap.begin();
  45     while (itr != m_stackmap.end())
  46     {
  47       if (itr->second->m_pStack != stack)
  48       {
  49         itr = m_stackmap.erase(itr);
  50       }
  51       else
  52       {
  53         ++itr;
  54       }
  55     }
  56   }
  57 }
  58
  59 bool CApplicationStackHelper::InitializeStack(const CFileItem & item)
  60 {
  61   if (!item.IsStack())
  62     return false;
  63
  64   CFileItemPtr stack(new CFileItem(item));
  65
  66   Clear();
  67   // read and determine kind of stack
  68   CStackDirectory dir;
  69   if (!dir.GetDirectory(item.GetURL(), *m_currentStack) || m_currentStack->IsEmpty())
  70     return false;
  71   for (int i = 0; i < m_currentStack->Size(); i++)
  72   {
  73     // keep cross-references between stack parts and the stack
  74     SetRegisteredStack(GetStackPartFileItem(i), stack);
  75     SetRegisteredStackPartNumber(GetStackPartFileItem(i), i);
  76   }
  77   m_currentStackIsDiscImageStack = CFileItem(CStackDirectory::GetFirstStackedFile(item.GetPath()), false).IsDiscImage();
  78
  79   return true;
  80 }
  81
  82 int CApplicationStackHelper::InitializeStackStartPartAndOffset(const CFileItem& item)
  83 {
  84   CVideoDatabase dbs;
  85   int64_t startoffset = 0;
  86
  87   // case 1: stacked ISOs
  88   if (m_currentStackIsDiscImageStack)
  89   {
  90     // first assume values passed to the stack
  91     int selectedFile = item.m_lStartPartNumber;
  92     startoffset = item.GetStartOffset();
  93
  94     // check if we instructed the stack to resume from default
  95     if (startoffset == STARTOFFSET_RESUME) // selected file is not specified, pick the 'last' resume point
  96     {
  97       if (dbs.Open())
  98       {
  99         CBookmark bookmark;
 100         std::string path = item.GetPath();
 101         if (item.HasProperty("original_listitem_url") && URIUtils::IsPlugin(item.GetProperty("original_listitem_url").asString()))
 102           path = item.GetProperty("original_listitem_url").asString();
 103         if (dbs.GetResumeBookMark(path, bookmark))
 104         {
 105           startoffset = CUtil::ConvertSecsToMilliSecs(bookmark.timeInSeconds);
 106           selectedFile = bookmark.partNumber;
 107         }
 108         dbs.Close();
 109       }
 110       else
 111         CLog::LogF(LOGERROR, "Cannot open VideoDatabase");
 112     }
 113
 114     // make sure that the selected part is within the boundaries
 115     if (selectedFile <= 0)
 116     {
 117       CLog::LogF(LOGWARNING, "Selected part {} out of range, playing part 1", selectedFile);
 118       selectedFile = 1;
 119     }
 120     else if (selectedFile > m_currentStack->Size())
 121     {
 122       CLog::LogF(LOGWARNING, "Selected part {} out of range, playing part {}", selectedFile,
 123                  m_currentStack->Size());
 124       selectedFile = m_currentStack->Size();
 125     }
 126
 127     // set startoffset in selected item, track stack item for updating purposes, and finally play disc part
 128     m_currentStackPosition = selectedFile - 1;
 129     startoffset = startoffset > 0 ? STARTOFFSET_RESUME : 0;
 130   }
 131   // case 2: all other stacks
 132   else
 133   {
 134     // see if we have the info in the database
 135     //! @todo If user changes the time speed (FPS via framerate conversion stuff)
 136     //!       then these times will be wrong.
 137     //!       Also, this is really just a hack for the slow load up times we have
 138     //!       A much better solution is a fast reader of FPS and fileLength
 139     //!       that we can use on a file to get it's time.
 140     std::vector<uint64_t> times;
 141     bool haveTimes(false);
 142
 143     if (dbs.Open())
 144     {
 145       haveTimes = dbs.GetStackTimes(item.GetPath(), times);
 146       dbs.Close();
 147     }
 148
 149     // calculate the total time of the stack
 150     uint64_t totalTimeMs = 0;
 151     for (int i = 0; i < m_currentStack->Size(); i++)
 152     {
 153       if (haveTimes)
 154       {
 155         // set end time in every part
 156         GetStackPartFileItem(i).SetEndOffset(times[i]);
 157       }
 158       else
 159       {
 160         int duration;
 161         if (!CDVDFileInfo::GetFileDuration(GetStackPartFileItem(i).GetPath(), duration))
 162         {
 163           m_currentStack->Clear();
 164           return false;
 165         }
 166         totalTimeMs += duration;
 167         // set end time in every part
 168         GetStackPartFileItem(i).SetEndOffset(totalTimeMs);
 169         times.push_back(totalTimeMs);
 170       }
 171       // set start time in every part
 172       SetRegisteredStackPartStartTimeMs(GetStackPartFileItem(i), GetStackPartStartTimeMs(i));
 173     }
 174     // set total time in every part
 175     totalTimeMs = GetStackTotalTimeMs();
 176     for (int i = 0; i < m_currentStack->Size(); i++)
 177       SetRegisteredStackTotalTimeMs(GetStackPartFileItem(i), totalTimeMs);
 178
 179     uint64_t msecs = item.GetStartOffset();
 180
 181     if (!haveTimes || item.GetStartOffset() == STARTOFFSET_RESUME)
 182     {
 183       if (dbs.Open())
 184       {
 185         // have our times now, so update the dB
 186         if (!haveTimes && !times.empty())
 187           dbs.SetStackTimes(item.GetPath(), times);
 188
 189         if (item.GetStartOffset() == STARTOFFSET_RESUME)
 190         {
 191           // can only resume seek here, not dvdstate
 192           CBookmark bookmark;
 193           std::string path = item.GetPath();
 194           if (item.HasProperty("original_listitem_url") && URIUtils::IsPlugin(item.GetProperty("original_listitem_url").asString()))
 195             path = item.GetProperty("original_listitem_url").asString();
 196           if (dbs.GetResumeBookMark(path, bookmark))
 197             msecs = static_cast<uint64_t>(bookmark.timeInSeconds * 1000);
 198           else
 199             msecs = 0;
 200         }
 201         dbs.Close();
 202       }
 203     }
 204
 205     m_currentStackPosition = GetStackPartNumberAtTimeMs(msecs);
 206     startoffset = msecs - GetStackPartStartTimeMs(m_currentStackPosition);
 207   }
 208   return startoffset;
 209 }
 210
 211 int CApplicationStackHelper::GetStackPartNumberAtTimeMs(uint64_t msecs)
 212 {
 213   if (msecs > 0)
 214   {
 215     // work out where to seek to
 216     for (int partNumber = 0; partNumber < m_currentStack->Size(); partNumber++)
 217     {
 218       if (msecs < GetStackPartEndTimeMs(partNumber))
 219         return partNumber;
 220     }
 221   }
 222   return 0;
 223 }
 224
 225 void CApplicationStackHelper::ClearAllRegisteredStackInformation()
 226 {
 227   m_stackmap.clear();
 228 }
 229
 230 std::shared_ptr<const CFileItem> CApplicationStackHelper::GetRegisteredStack(
 231     const CFileItem& item) const
 232 {
 233   return GetStackPartInformation(item.GetPath())->m_pStack;
 234 }
 235
 236 bool CApplicationStackHelper::HasRegisteredStack(const CFileItem& item) const
 237 {
 238   const auto it = m_stackmap.find(item.GetPath());
 239   return it != m_stackmap.end() && it->second != nullptr;
 240 }
 241
 242 void CApplicationStackHelper::SetRegisteredStack(const CFileItem& item, CFileItemPtr stackItem)
 243 {
 244   GetStackPartInformation(item.GetPath())->m_pStack = std::move(stackItem);
 245 }
 246
 247 int CApplicationStackHelper::GetRegisteredStackPartNumber(const CFileItem& item)
 248 {
 249   return GetStackPartInformation(item.GetPath())->m_lStackPartNumber;
 250 }
 251
 252 void CApplicationStackHelper::SetRegisteredStackPartNumber(const CFileItem& item, int partNumber)
 253 {
 254   GetStackPartInformation(item.GetPath())->m_lStackPartNumber = partNumber;
 255 }
 256
 257 uint64_t CApplicationStackHelper::GetRegisteredStackPartStartTimeMs(const CFileItem& item) const
 258 {
 259   return GetStackPartInformation(item.GetPath())->m_lStackPartStartTimeMs;
 260 }
 261
 262 void CApplicationStackHelper::SetRegisteredStackPartStartTimeMs(const CFileItem& item, uint64_t startTime)
 263 {
 264   GetStackPartInformation(item.GetPath())->m_lStackPartStartTimeMs = startTime;
 265 }
 266
 267 uint64_t CApplicationStackHelper::GetRegisteredStackTotalTimeMs(const CFileItem& item) const
 268 {
 269   return GetStackPartInformation(item.GetPath())->m_lStackTotalTimeMs;
 270 }
 271
 272 void CApplicationStackHelper::SetRegisteredStackTotalTimeMs(const CFileItem& item, uint64_t totalTime)
 273 {
 274   GetStackPartInformation(item.GetPath())->m_lStackTotalTimeMs = totalTime;
 275 }
 276
 277 CApplicationStackHelper::StackPartInformationPtr CApplicationStackHelper::GetStackPartInformation(
 278     const std::string& key)
 279 {
 280   if (m_stackmap.count(key) == 0)
 281   {
 282     StackPartInformationPtr value(new StackPartInformation());
 283     m_stackmap[key] = value;
 284   }
 285   return m_stackmap[key];
 286 }
 287
 288 CApplicationStackHelper::StackPartInformationPtr CApplicationStackHelper::GetStackPartInformation(
 289     const std::string& key) const
 290 {
 291   const auto it = m_stackmap.find(key);
 292   if (it == m_stackmap.end())
 293     return std::make_shared<StackPartInformation>();
 294   return it->second;
 295 }