xbmc/cores/VideoPlayer/DVDOverlayContainer.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 "DVDOverlayContainer.h"
  10
  11 #include "DVDCodecs/Overlay/DVDOverlay.h"
  12 #include "DVDInputStreams/DVDInputStreamNavigator.h"
  13
  14 #include <memory>
  15 #include <mutex>
  16
  17 CDVDOverlayContainer::~CDVDOverlayContainer()
  18 {
  19   Clear();
  20 }
  21
  22 void CDVDOverlayContainer::ProcessAndAddOverlayIfValid(const std::shared_ptr<CDVDOverlay>& pOverlay)
  23 {
  24   std::unique_lock<CCriticalSection> lock(*this);
  25
  26   // markup any non ending overlays, to finish
  27   // when this new one starts, there can be
  28   // multiple overlays queued at same start
  29   // point so only stop them when we get a
  30   // new startpoint
  31   for(int i = m_overlays.size();i>0;)
  32   {
  33     i--;
  34     if(m_overlays[i]->iPTSStopTime)
  35     {
  36       if(!m_overlays[i]->replace)
  37         break;
  38       if(m_overlays[i]->iPTSStopTime <= pOverlay->iPTSStartTime)
  39         break;
  40     }
  41
  42     if (m_overlays[i]->iPTSStartTime != pOverlay->iPTSStartTime)
  43       m_overlays[i]->iPTSStopTime = pOverlay->iPTSStartTime;
  44   }
  45
  46   m_overlays.emplace_back(pOverlay);
  47 }
  48
  49 VecOverlays* CDVDOverlayContainer::GetOverlays()
  50 {
  51   return &m_overlays;
  52 }
  53
  54 VecOverlays::iterator CDVDOverlayContainer::Remove(VecOverlays::iterator itOverlay)
  55 {
  56   std::unique_lock<CCriticalSection> lock(*this);
  57   return m_overlays.erase(itOverlay);
  58 }
  59
  60 void CDVDOverlayContainer::CleanUp(double pts)
  61 {
  62   std::unique_lock<CCriticalSection> lock(*this);
  63
  64   auto it = m_overlays.begin();
  65   while (it != m_overlays.end())
  66   {
  67     const std::shared_ptr<CDVDOverlay>& pOverlay = *it;
  68
  69     // never delete forced overlays, they are used in menu's
  70     // clear takes care of removing them
  71     // also if stoptime = 0, it means the next subtitles will use its starttime as the stoptime
  72     // which means we cannot delete overlays with stoptime 0
  73     if (!pOverlay->bForced && pOverlay->iPTSStopTime <= pts && pOverlay->iPTSStopTime != 0)
  74     {
  75       //CLog::Log(LOGDEBUG,"CDVDOverlay::CleanUp, removing {}", (int)(pts / 1000));
  76       //CLog::Log(LOGDEBUG,"CDVDOverlay::CleanUp, remove, start : {}, stop : {}", (int)(pOverlay->iPTSStartTime / 1000), (int)(pOverlay->iPTSStopTime / 1000));
  77       it = Remove(it);
  78       continue;
  79     }
  80     else if (pOverlay->bForced)
  81     {
  82       //Check for newer replacements
  83       auto it2 = it;
  84       bool bNewer = false;
  85       while (!bNewer && ++it2 != m_overlays.end())
  86       {
  87         const std::shared_ptr<CDVDOverlay>& pOverlay2 = *it2;
  88         if (pOverlay2->bForced && pOverlay2->iPTSStartTime <= pts) bNewer = true;
  89       }
  90
  91       if (bNewer)
  92       {
  93         it = Remove(it);
  94         continue;
  95       }
  96     }
  97     ++it;
  98   }
  99
 100 }
 101
 102 void CDVDOverlayContainer::Flush()
 103 {
 104   std::unique_lock<CCriticalSection> lock(*this);
 105
 106   // Flush only the overlays marked as flushable
 107   m_overlays.erase(std::remove_if(m_overlays.begin(), m_overlays.end(),
 108                                   [](const std::shared_ptr<CDVDOverlay>& ov) {
 109                                     return ov->IsOverlayContainerFlushable();
 110                                   }),
 111                    m_overlays.end());
 112 }
 113
 114 void CDVDOverlayContainer::Clear()
 115 {
 116   std::unique_lock<CCriticalSection> lock(*this);
 117   m_overlays.clear();
 118 }
 119
 120 size_t CDVDOverlayContainer::GetSize()
 121 {
 122   return m_overlays.size();
 123 }
 124
 125 bool CDVDOverlayContainer::ContainsOverlayType(DVDOverlayType type)
 126 {
 127   bool result = false;
 128
 129   std::unique_lock<CCriticalSection> lock(*this);
 130
 131   auto it = m_overlays.begin();
 132   while (!result && it != m_overlays.end())
 133   {
 134     if ((*it)->IsOverlayType(type)) result = true;
 135     ++it;
 136   }
 137
 138   return result;
 139 }
 140
 141 /*
 142  * iAction should be LIBDVDNAV_BUTTON_NORMAL or LIBDVDNAV_BUTTON_CLICKED
 143  */
 144 void CDVDOverlayContainer::UpdateOverlayInfo(
 145     const std::shared_ptr<CDVDInputStreamNavigator>& pStream, CDVDDemuxSPU* pSpu, int iAction)
 146 {
 147   std::unique_lock<CCriticalSection> lock(*this);
 148
 149   pStream->CheckButtons();
 150
 151   //Update any forced overlays.
 152   for(VecOverlays::iterator it = m_overlays.begin(); it != m_overlays.end(); ++it )
 153   {
 154     if ((*it)->IsOverlayType(DVDOVERLAY_TYPE_SPU))
 155     {
 156       auto pOverlaySpu = std::static_pointer_cast<CDVDOverlaySpu>(*it);
 157
 158       // make sure its a forced (menu) overlay
 159       // set menu spu color and alpha data if there is a valid menu overlay
 160       if (pOverlaySpu->bForced)
 161       {
 162         if (pOverlaySpu.use_count() > 1)
 163         {
 164           pOverlaySpu = std::make_shared<CDVDOverlaySpu>(*pOverlaySpu);
 165           (*it) = pOverlaySpu;
 166         }
 167
 168         if (pStream->GetCurrentButtonInfo(*pOverlaySpu, pSpu, iAction))
 169         {
 170           pOverlaySpu->m_textureid = 0;
 171         }
 172
 173       }
 174     }
 175   }
 176 }