xbmc/cores/VideoPlayer/VideoPlayer.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 "VideoPlayer.h"
  10
  11 #include "DVDCodecs/DVDCodecUtils.h"
  12 #include "DVDDemuxers/DVDDemux.h"
  13 #include "DVDDemuxers/DVDDemuxCC.h"
  14 #include "DVDDemuxers/DVDDemuxFFmpeg.h"
  15 #include "DVDDemuxers/DVDDemuxUtils.h"
  16 #include "DVDDemuxers/DVDDemuxVobsub.h"
  17 #include "DVDDemuxers/DVDFactoryDemuxer.h"
  18 #include "DVDInputStreams/DVDFactoryInputStream.h"
  19 #include "DVDInputStreams/DVDInputStream.h"
  20 #include "network/NetworkFileItemClassify.h"
  21 #if defined(HAVE_LIBBLURAY)
  22 #include "DVDInputStreams/DVDInputStreamBluray.h"
  23 #endif
  24 #include "DVDInputStreams/DVDInputStreamNavigator.h"
  25 #include "DVDInputStreams/InputStreamPVRBase.h"
  26 #include "DVDMessage.h"
  27 #include "FileItem.h"
  28 #include "GUIUserMessages.h"
  29 #include "LangInfo.h"
  30 #include "ServiceBroker.h"
  31 #include "URL.h"
  32 #include "Util.h"
  33 #include "VideoPlayerAudio.h"
  34 #include "VideoPlayerRadioRDS.h"
  35 #include "VideoPlayerVideo.h"
  36 #include "application/Application.h"
  37 #include "cores/DataCacheCore.h"
  38 #include "cores/EdlEdit.h"
  39 #include "cores/FFmpeg.h"
  40 #include "cores/VideoPlayer/Process/ProcessInfo.h"
  41 #include "cores/VideoPlayer/VideoRenderers/RenderManager.h"
  42 #include "dialogs/GUIDialogKaiToast.h"
  43 #include "guilib/GUIComponent.h"
  44 #include "guilib/GUIWindowManager.h"
  45 #include "guilib/LocalizeStrings.h"
  46 #include "guilib/StereoscopicsManager.h"
  47 #include "input/actions/Action.h"
  48 #include "input/actions/ActionIDs.h"
  49 #include "messaging/ApplicationMessenger.h"
  50 #include "network/NetworkFileItemClassify.h"
  51 #include "settings/AdvancedSettings.h"
  52 #include "settings/Settings.h"
  53 #include "settings/SettingsComponent.h"
  54 #include "threads/SingleLock.h"
  55 #include "utils/FontUtils.h"
  56 #include "utils/JobManager.h"
  57 #include "utils/LangCodeExpander.h"
  58 #include "utils/StreamDetails.h"
  59 #include "utils/StreamUtils.h"
  60 #include "utils/StringUtils.h"
  61 #include "utils/URIUtils.h"
  62 #include "utils/Variant.h"
  63 #include "utils/log.h"
  64 #include "video/Bookmark.h"
  65 #include "video/VideoInfoTag.h"
  66 #include "windowing/WinSystem.h"
  67
  68 #include <chrono>
  69 #include <iterator>
  70 #include <memory>
  71 #include <mutex>
  72 #include <utility>
  73
  74 using namespace KODI;
  75 using namespace std::chrono_literals;
  76
  77 //------------------------------------------------------------------------------
  78 // selection streams
  79 //------------------------------------------------------------------------------
  80
  81 #define PREDICATE_RETURN(lh, rh) \
  82   do { \
  83     if((lh) != (rh)) \
  84       return (lh) > (rh); \
  85   } while(0)
  86
  87 class PredicateSubtitleFilter
  88 {
  89 private:
  90   std::string audiolang;
  91   bool original;
  92   bool nosub;
  93   bool onlyforced;
  94   int currentSubStream;
  95 public:
  96   /** \brief The class' operator() decides if the given (subtitle) SelectionStream is relevant wrt.
  97    *          preferred subtitle language and audio language. If the subtitle is relevant <B>false</B> false is returned.
  98    *
  99    *          A subtitle is relevant if
 100    *          - it was previously selected, or
 101    *          - it's an external sub, or
 102    *          - it's a forced sub and "original stream's language" was selected and audio stream language matches, or
 103    *          - it's a default and a forced sub (could lead to users seeing forced subs in a foreign language!), or
 104    *          - its language matches the preferred subtitle's language (unequal to "original stream's language")
 105    */
 106   explicit PredicateSubtitleFilter(const std::string& lang, int subStream)
 107   : audiolang(lang),
 108     currentSubStream(subStream)
 109   {
 110     const std::string subtitleLang = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_SUBTITLELANGUAGE);
 111     original = StringUtils::EqualsNoCase(subtitleLang, "original");
 112     nosub = StringUtils::EqualsNoCase(subtitleLang, "none");
 113     onlyforced = StringUtils::EqualsNoCase(subtitleLang, "forced_only");
 114   };
 115
 116   bool operator()(const SelectionStream& ss) const
 117   {
 118     if (ss.type_index == currentSubStream)
 119       return false;
 120
 121     if (nosub)
 122       return true;
 123
 124     if (onlyforced)
 125     {
 126       if ((ss.flags & StreamFlags::FLAG_FORCED) && g_LangCodeExpander.CompareISO639Codes(ss.language, audiolang))
 127         return false;
 128       else
 129         return true;
 130     }
 131
 132     if(STREAM_SOURCE_MASK(ss.source) == STREAM_SOURCE_DEMUX_SUB || STREAM_SOURCE_MASK(ss.source) == STREAM_SOURCE_TEXT)
 133       return false;
 134
 135     if ((ss.flags & StreamFlags::FLAG_FORCED) && g_LangCodeExpander.CompareISO639Codes(ss.language, audiolang))
 136       return false;
 137
 138     if ((ss.flags & StreamFlags::FLAG_FORCED) && (ss.flags & StreamFlags::FLAG_DEFAULT))
 139       return false;
 140
 141     if (ss.language == "cc" && ss.flags & StreamFlags::FLAG_HEARING_IMPAIRED)
 142       return false;
 143
 144     if(!original)
 145     {
 146       std::string subtitle_language = g_langInfo.GetSubtitleLanguage();
 147       if (g_LangCodeExpander.CompareISO639Codes(subtitle_language, ss.language))
 148         return false;
 149     }
 150     else if (ss.flags & StreamFlags::FLAG_DEFAULT)
 151       return false;
 152
 153     return true;
 154   }
 155 };
 156
 157 class PredicateAudioFilter
 158 {
 159 private:
 160   int currentAudioStream;
 161   bool preferStereo;
 162 public:
 163   explicit PredicateAudioFilter(int audioStream, bool preferStereo)
 164     : currentAudioStream(audioStream)
 165     , preferStereo(preferStereo)
 166   {
 167   };
 168   bool operator()(const SelectionStream& lh, const SelectionStream& rh)
 169   {
 170     PREDICATE_RETURN(lh.type_index == currentAudioStream
 171                      , rh.type_index == currentAudioStream);
 172
 173     const std::shared_ptr<CSettings> settings = CServiceBroker::GetSettingsComponent()->GetSettings();
 174
 175     if (!StringUtils::EqualsNoCase(settings->GetString(CSettings::SETTING_LOCALE_AUDIOLANGUAGE), "mediadefault"))
 176     {
 177       if (!StringUtils::EqualsNoCase(settings->GetString(CSettings::SETTING_LOCALE_AUDIOLANGUAGE), "original"))
 178       {
 179         std::string audio_language = g_langInfo.GetAudioLanguage();
 180         PREDICATE_RETURN(g_LangCodeExpander.CompareISO639Codes(audio_language, lh.language)
 181           , g_LangCodeExpander.CompareISO639Codes(audio_language, rh.language));
 182       }
 183       else
 184       {
 185         PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_ORIGINAL,
 186           rh.flags & StreamFlags::FLAG_ORIGINAL);
 187       }
 188
 189       bool hearingimp = settings->GetBool(CSettings::SETTING_ACCESSIBILITY_AUDIOHEARING);
 190       PREDICATE_RETURN(!hearingimp ? !(lh.flags & StreamFlags::FLAG_HEARING_IMPAIRED) : lh.flags & StreamFlags::FLAG_HEARING_IMPAIRED
 191                        , !hearingimp ? !(rh.flags & StreamFlags::FLAG_HEARING_IMPAIRED) : rh.flags & StreamFlags::FLAG_HEARING_IMPAIRED);
 192
 193       bool visualimp = settings->GetBool(CSettings::SETTING_ACCESSIBILITY_AUDIOVISUAL);
 194       PREDICATE_RETURN(!visualimp ? !(lh.flags & StreamFlags::FLAG_VISUAL_IMPAIRED) : lh.flags & StreamFlags::FLAG_VISUAL_IMPAIRED
 195                        , !visualimp ? !(rh.flags & StreamFlags::FLAG_VISUAL_IMPAIRED) : rh.flags & StreamFlags::FLAG_VISUAL_IMPAIRED);
 196     }
 197
 198     if (settings->GetBool(CSettings::SETTING_VIDEOPLAYER_PREFERDEFAULTFLAG))
 199     {
 200       PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_DEFAULT,
 201                        rh.flags & StreamFlags::FLAG_DEFAULT);
 202     }
 203
 204     if (preferStereo)
 205       PREDICATE_RETURN(lh.channels == 2,
 206                        rh.channels == 2);
 207     else
 208       PREDICATE_RETURN(lh.channels,
 209                        rh.channels);
 210
 211     PREDICATE_RETURN(StreamUtils::GetCodecPriority(lh.codec),
 212                      StreamUtils::GetCodecPriority(rh.codec));
 213
 214     PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_DEFAULT,
 215                      rh.flags & StreamFlags::FLAG_DEFAULT);
 216     return false;
 217   };
 218 };
 219
 220 /** \brief The class' operator() decides if the given (subtitle) SelectionStream lh is 'better than' the given (subtitle) SelectionStream rh.
 221 *          If lh is 'better than' rh the return value is true, false otherwise.
 222 *
 223 *          A subtitle lh is 'better than' a subtitle rh (in evaluation order) if
 224 *          - lh was previously selected, or
 225 *          - lh is an external sub and rh not, or
 226 *          - lh is a forced sub and ("original stream's language" was selected or subtitles are off) and audio stream language matches sub language and rh not, or
 227 *          - lh is a default sub and ("original stream's language" was selected or subtitles are off) and audio stream language matches sub language and rh not, or
 228 *          - lh is a sub where audio stream language matches sub language and (original stream's language" was selected or subtitles are off) and rh not, or
 229 *          - lh is a forced sub and a default sub ("original stream's language" was selected or subtitles are off)
 230 *          - lh is an external sub and its language matches the preferred subtitle's language (unequal to "original stream's language") and rh not, or
 231 *          - lh is language matches the preferred subtitle's language (unequal to "original stream's language") and rh not, or
 232 *          - lh is a default sub and rh not
 233 */
 234 class PredicateSubtitlePriority
 235 {
 236 private:
 237   std::string audiolang;
 238   bool original;
 239   bool subson;
 240   PredicateSubtitleFilter filter;
 241   int subStream;
 242 public:
 243   explicit PredicateSubtitlePriority(const std::string& lang, int stream, bool ison)
 244   : audiolang(lang),
 245     original(StringUtils::EqualsNoCase(CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(CSettings::SETTING_LOCALE_SUBTITLELANGUAGE), "original")),
 246     subson(ison),
 247     filter(lang, stream),
 248     subStream(stream)
 249   {
 250   };
 251
 252   bool relevant(const SelectionStream& ss) const
 253   {
 254     return !filter(ss);
 255   }
 256
 257   bool operator()(const SelectionStream& lh, const SelectionStream& rh) const
 258   {
 259     PREDICATE_RETURN(relevant(lh)
 260                    , relevant(rh));
 261
 262     PREDICATE_RETURN(lh.type_index == subStream
 263                    , rh.type_index == subStream);
 264
 265     // prefer external subs
 266     PREDICATE_RETURN(STREAM_SOURCE_MASK(lh.source) == STREAM_SOURCE_DEMUX_SUB || STREAM_SOURCE_MASK(lh.source) == STREAM_SOURCE_TEXT
 267                    , STREAM_SOURCE_MASK(rh.source) == STREAM_SOURCE_DEMUX_SUB || STREAM_SOURCE_MASK(rh.source) == STREAM_SOURCE_TEXT);
 268
 269     if (!subson || original)
 270     {
 271       PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_FORCED && g_LangCodeExpander.CompareISO639Codes(lh.language, audiolang)
 272                      , rh.flags & StreamFlags::FLAG_FORCED && g_LangCodeExpander.CompareISO639Codes(rh.language, audiolang));
 273
 274       PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_DEFAULT && g_LangCodeExpander.CompareISO639Codes(lh.language, audiolang)
 275                      , rh.flags & StreamFlags::FLAG_DEFAULT && g_LangCodeExpander.CompareISO639Codes(rh.language, audiolang));
 276
 277       PREDICATE_RETURN(g_LangCodeExpander.CompareISO639Codes(lh.language, audiolang)
 278                      , g_LangCodeExpander.CompareISO639Codes(rh.language, audiolang));
 279
 280       PREDICATE_RETURN((lh.flags & (StreamFlags::FLAG_FORCED | StreamFlags::FLAG_DEFAULT)) == (StreamFlags::FLAG_FORCED | StreamFlags::FLAG_DEFAULT)
 281                      , (rh.flags & (StreamFlags::FLAG_FORCED | StreamFlags::FLAG_DEFAULT)) == (StreamFlags::FLAG_FORCED | StreamFlags::FLAG_DEFAULT));
 282
 283     }
 284
 285     std::string subtitle_language = g_langInfo.GetSubtitleLanguage();
 286     if (!original)
 287     {
 288       PREDICATE_RETURN((STREAM_SOURCE_MASK(lh.source) == STREAM_SOURCE_DEMUX_SUB || STREAM_SOURCE_MASK(lh.source) == STREAM_SOURCE_TEXT) && g_LangCodeExpander.CompareISO639Codes(subtitle_language, lh.language)
 289                      , (STREAM_SOURCE_MASK(rh.source) == STREAM_SOURCE_DEMUX_SUB || STREAM_SOURCE_MASK(rh.source) == STREAM_SOURCE_TEXT) && g_LangCodeExpander.CompareISO639Codes(subtitle_language, rh.language));
 290     }
 291
 292     if (!original)
 293     {
 294       PREDICATE_RETURN(g_LangCodeExpander.CompareISO639Codes(subtitle_language, lh.language)
 295                      , g_LangCodeExpander.CompareISO639Codes(subtitle_language, rh.language));
 296
 297       bool hearingimp = CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_ACCESSIBILITY_SUBHEARING);
 298       PREDICATE_RETURN(!hearingimp ? !(lh.flags & StreamFlags::FLAG_HEARING_IMPAIRED) : lh.flags & StreamFlags::FLAG_HEARING_IMPAIRED
 299                      , !hearingimp ? !(rh.flags & StreamFlags::FLAG_HEARING_IMPAIRED) : rh.flags & StreamFlags::FLAG_HEARING_IMPAIRED);
 300     }
 301
 302     PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_DEFAULT
 303                    , rh.flags & StreamFlags::FLAG_DEFAULT);
 304
 305     return false;
 306   }
 307 };
 308
 309 class PredicateVideoFilter
 310 {
 311 private:
 312   int currentVideoStream;
 313 public:
 314   explicit PredicateVideoFilter(int videoStream) : currentVideoStream(videoStream)
 315   {
 316   };
 317   bool operator()(const SelectionStream& lh, const SelectionStream& rh)
 318   {
 319     PREDICATE_RETURN(lh.type_index == currentVideoStream,
 320                      rh.type_index == currentVideoStream);
 321
 322     PREDICATE_RETURN(lh.flags & StreamFlags::FLAG_DEFAULT,
 323                      rh.flags & StreamFlags::FLAG_DEFAULT);
 324     return false;
 325   }
 326 };
 327
 328 void CSelectionStreams::Clear(StreamType type, StreamSource source)
 329 {
 330   auto new_end = std::remove_if(m_Streams.begin(), m_Streams.end(),
 331                                 [type, source](const SelectionStream &stream)
 332                                 {
 333                                   return (type == STREAM_NONE || stream.type == type) &&
 334                                   (source == 0 || stream.source == source);
 335                                 });
 336   m_Streams.erase(new_end, m_Streams.end());
 337 }
 338
 339 SelectionStream& CSelectionStreams::Get(StreamType type, int index)
 340 {
 341   return const_cast<SelectionStream&>(std::as_const(*this).Get(type, index));
 342 }
 343
 344 const SelectionStream& CSelectionStreams::Get(StreamType type, int index) const
 345 {
 346   int count = -1;
 347   for (size_t i = 0; i < m_Streams.size(); ++i)
 348   {
 349     if (m_Streams[i].type != type)
 350       continue;
 351     count++;
 352     if (count == index)
 353       return m_Streams[i];
 354   }
 355   return m_invalid;
 356 }
 357
 358 std::vector<SelectionStream> CSelectionStreams::Get(StreamType type)
 359 {
 360   std::vector<SelectionStream> streams;
 361   std::copy_if(m_Streams.begin(), m_Streams.end(), std::back_inserter(streams),
 362                [type](const SelectionStream &stream)
 363                {
 364                  return stream.type == type;
 365                });
 366   return streams;
 367 }
 368
 369 bool CSelectionStreams::Get(StreamType type, StreamFlags flag, SelectionStream& out)
 370 {
 371   for(size_t i=0;i<m_Streams.size();i++)
 372   {
 373     if(m_Streams[i].type != type)
 374       continue;
 375     if((m_Streams[i].flags & flag) != flag)
 376       continue;
 377     out = m_Streams[i];
 378     return true;
 379   }
 380   return false;
 381 }
 382
 383 int CSelectionStreams::TypeIndexOf(StreamType type, int source, int64_t demuxerId, int id) const
 384 {
 385   if (id < 0)
 386     return -1;
 387
 388   auto it = std::find_if(m_Streams.begin(), m_Streams.end(),
 389     [&](const SelectionStream& stream) {return stream.type == type
 390     && stream.source == source && stream.id == id
 391     && stream.demuxerId == demuxerId;});
 392
 393   if (it != m_Streams.end())
 394     return it->type_index;
 395   else
 396     return -1;
 397 }
 398
 399 int CSelectionStreams::Source(StreamSource source, const std::string& filename)
 400 {
 401   int index = source - 1;
 402   for (size_t i=0; i<m_Streams.size(); i++)
 403   {
 404     SelectionStream &s = m_Streams[i];
 405     if (STREAM_SOURCE_MASK(s.source) != source)
 406       continue;
 407     // if it already exists, return same
 408     if (s.filename == filename)
 409       return s.source;
 410     if (index < s.source)
 411       index = s.source;
 412   }
 413   // return next index
 414   return index + 1;
 415 }
 416
 417 void CSelectionStreams::Update(SelectionStream& s)
 418 {
 419   int index = TypeIndexOf(s.type, s.source, s.demuxerId, s.id);
 420   if(index >= 0)
 421   {
 422     SelectionStream& o = Get(s.type, index);
 423     s.type_index = o.type_index;
 424     o = s;
 425   }
 426   else
 427   {
 428     s.type_index = CountType(s.type);
 429     m_Streams.push_back(s);
 430   }
 431 }
 432
 433 void CSelectionStreams::Update(const std::shared_ptr<CDVDInputStream>& input,
 434                                CDVDDemux* demuxer,
 435                                const std::string& filename2)
 436 {
 437   if(input && input->IsStreamType(DVDSTREAM_TYPE_DVD))
 438   {
 439     std::shared_ptr<CDVDInputStreamNavigator> nav = std::static_pointer_cast<CDVDInputStreamNavigator>(input);
 440     std::string filename = nav->GetFileName();
 441     int source = Source(STREAM_SOURCE_NAV, filename);
 442
 443     int count;
 444     count = nav->GetAudioStreamCount();
 445     for(int i=0;i<count;i++)
 446     {
 447       SelectionStream s;
 448       s.source   = source;
 449       s.type     = STREAM_AUDIO;
 450       s.id       = i;
 451       s.flags    = StreamFlags::FLAG_NONE;
 452       s.filename = filename;
 453
 454       AudioStreamInfo info = nav->GetAudioStreamInfo(i);
 455       s.name     = info.name;
 456       s.codec    = info.codecName;
 457       s.language = g_LangCodeExpander.ConvertToISO6392B(info.language);
 458       s.channels = info.channels;
 459       s.flags = info.flags;
 460       Update(s);
 461     }
 462
 463     count = nav->GetSubTitleStreamCount();
 464     for(int i=0;i<count;i++)
 465     {
 466       SelectionStream s;
 467       s.source   = source;
 468       s.type     = STREAM_SUBTITLE;
 469       s.id       = i;
 470       s.filename = filename;
 471       s.channels = 0;
 472
 473       SubtitleStreamInfo info = nav->GetSubtitleStreamInfo(i);
 474       s.name     = info.name;
 475       s.flags = info.flags;
 476       s.language = g_LangCodeExpander.ConvertToISO6392B(info.language);
 477       Update(s);
 478     }
 479
 480     VideoStreamInfo info = nav->GetVideoStreamInfo();
 481     for (int i = 1; i <= info.angles; i++)
 482     {
 483       SelectionStream s;
 484       s.source = source;
 485       s.type = STREAM_VIDEO;
 486       s.id = i;
 487       s.flags = StreamFlags::FLAG_NONE;
 488       s.filename = filename;
 489       s.channels = 0;
 490       s.aspect_ratio = info.videoAspectRatio;
 491       s.width = info.width;
 492       s.height = info.height;
 493       s.codec = info.codecName;
 494       s.name = StringUtils::Format("{} {}", g_localizeStrings.Get(38032), i);
 495       Update(s);
 496     }
 497   }
 498   else if(demuxer)
 499   {
 500     std::string filename = demuxer->GetFileName();
 501     int source;
 502     if(input) /* hack to know this is sub decoder */
 503       source = Source(STREAM_SOURCE_DEMUX, filename);
 504     else if (!filename2.empty())
 505       source = Source(STREAM_SOURCE_DEMUX_SUB, filename);
 506     else
 507       source = Source(STREAM_SOURCE_VIDEOMUX, filename);
 508
 509     for (auto stream : demuxer->GetStreams())
 510     {
 511       /* skip streams with no type */
 512       if (stream->type == STREAM_NONE)
 513         continue;
 514       /* make sure stream is marked with right source */
 515       stream->source = source;
 516
 517       SelectionStream s;
 518       s.source   = source;
 519       s.type     = stream->type;
 520       s.id       = stream->uniqueId;
 521       s.demuxerId = stream->demuxerId;
 522       s.language = g_LangCodeExpander.ConvertToISO6392B(stream->language);
 523       s.flags    = stream->flags;
 524       s.filename = demuxer->GetFileName();
 525       s.filename2 = filename2;
 526       s.name = stream->GetStreamName();
 527       s.codec    = demuxer->GetStreamCodecName(stream->demuxerId, stream->uniqueId);
 528       s.channels = 0; // Default to 0. Overwrite if STREAM_AUDIO below.
 529       if(stream->type == STREAM_VIDEO)
 530       {
 531         CDemuxStreamVideo* vstream = static_cast<CDemuxStreamVideo*>(stream);
 532         s.width = vstream->iWidth;
 533         s.height = vstream->iHeight;
 534         s.aspect_ratio = vstream->fAspect;
 535         s.stereo_mode = vstream->stereo_mode;
 536         s.bitrate = vstream->iBitRate;
 537         s.hdrType = vstream->hdr_type;
 538       }
 539       if(stream->type == STREAM_AUDIO)
 540       {
 541         std::string type;
 542         type = static_cast<CDemuxStreamAudio*>(stream)->GetStreamType();
 543         if(type.length() > 0)
 544         {
 545           if(s.name.length() > 0)
 546             s.name += " - ";
 547           s.name += type;
 548         }
 549         s.channels = static_cast<CDemuxStreamAudio*>(stream)->iChannels;
 550         s.bitrate = static_cast<CDemuxStreamAudio*>(stream)->iBitRate;
 551       }
 552       Update(s);
 553     }
 554   }
 555   CServiceBroker::GetDataCacheCore().SignalAudioInfoChange();
 556   CServiceBroker::GetDataCacheCore().SignalVideoInfoChange();
 557   CServiceBroker::GetDataCacheCore().SignalSubtitleInfoChange();
 558 }
 559
 560 void CSelectionStreams::Update(const std::shared_ptr<CDVDInputStream>& input, CDVDDemux* demuxer)
 561 {
 562   Update(input, demuxer, "");
 563 }
 564
 565 int CSelectionStreams::CountTypeOfSource(StreamType type, StreamSource source) const
 566 {
 567   return std::count_if(m_Streams.begin(), m_Streams.end(),
 568     [&](const SelectionStream& stream) {return (stream.type == type) && (stream.source == source);});
 569 }
 570
 571 int CSelectionStreams::CountType(StreamType type) const
 572 {
 573   return std::count_if(m_Streams.begin(), m_Streams.end(),
 574                        [&](const SelectionStream& stream) { return stream.type == type; });
 575 }
 576
 577 //------------------------------------------------------------------------------
 578 // main class
 579 //------------------------------------------------------------------------------
 580
 581 void CVideoPlayer::CreatePlayers()
 582 {
 583   if (m_players_created)
 584     return;
 585
 586   m_VideoPlayerVideo =
 587       new CVideoPlayerVideo(&m_clock, &m_overlayContainer, m_messenger, m_renderManager,
 588                             *m_processInfo, m_messageQueueTimeSize);
 589   m_VideoPlayerAudio =
 590       new CVideoPlayerAudio(&m_clock, m_messenger, *m_processInfo, m_messageQueueTimeSize);
 591   m_VideoPlayerSubtitle = new CVideoPlayerSubtitle(&m_overlayContainer, *m_processInfo);
 592   m_VideoPlayerTeletext = new CDVDTeletextData(*m_processInfo);
 593   m_VideoPlayerRadioRDS = new CDVDRadioRDSData(*m_processInfo);
 594   m_VideoPlayerAudioID3 = std::make_unique<CVideoPlayerAudioID3>(*m_processInfo);
 595   m_players_created = true;
 596 }
 597
 598 void CVideoPlayer::DestroyPlayers()
 599 {
 600   if (!m_players_created)
 601     return;
 602
 603   delete m_VideoPlayerVideo;
 604   delete m_VideoPlayerAudio;
 605   delete m_VideoPlayerSubtitle;
 606   delete m_VideoPlayerTeletext;
 607   delete m_VideoPlayerRadioRDS;
 608   m_VideoPlayerAudioID3.reset();
 609
 610   m_players_created = false;
 611 }
 612
 613 CVideoPlayer::CVideoPlayer(IPlayerCallback& callback)
 614   : IPlayer(callback),
 615     CThread("VideoPlayer"),
 616     m_CurrentAudio(STREAM_AUDIO, VideoPlayer_AUDIO),
 617     m_CurrentVideo(STREAM_VIDEO, VideoPlayer_VIDEO),
 618     m_CurrentSubtitle(STREAM_SUBTITLE, VideoPlayer_SUBTITLE),
 619     m_CurrentTeletext(STREAM_TELETEXT, VideoPlayer_TELETEXT),
 620     m_CurrentRadioRDS(STREAM_RADIO_RDS, VideoPlayer_RDS),
 621     m_CurrentAudioID3(STREAM_AUDIO_ID3, VideoPlayer_ID3),
 622     m_messenger("player"),
 623     m_outboundEvents(std::make_unique<CJobQueue>(false, 1, CJob::PRIORITY_NORMAL)),
 624     m_pInputStream(nullptr),
 625     m_pDemuxer(nullptr),
 626     m_pSubtitleDemuxer(nullptr),
 627     m_pCCDemuxer(nullptr),
 628     m_renderManager(m_clock, this)
 629 {
 630   m_players_created = false;
 631
 632   m_dvd.Clear();
 633   m_State.Clear();
 634
 635   m_bAbortRequest = false;
 636   m_offset_pts = 0.0;
 637   m_playSpeed = DVD_PLAYSPEED_NORMAL;
 638   m_streamPlayerSpeed = DVD_PLAYSPEED_NORMAL;
 639   m_caching = CACHESTATE_DONE;
 640   m_HasVideo = false;
 641   m_HasAudio = false;
 642   m_UpdateStreamDetails = false;
 643
 644   const int tenthsSeconds = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(
 645       CSettings::SETTING_VIDEOPLAYER_QUEUETIMESIZE);
 646
 647   m_messageQueueTimeSize = static_cast<double>(tenthsSeconds) / 10.0;
 648
 649   m_SkipCommercials = true;
 650
 651   m_processInfo.reset(CProcessInfo::CreateInstance());
 652   // if we have a gui, register the cache
 653   m_processInfo->SetDataCache(&CServiceBroker::GetDataCacheCore());
 654   m_processInfo->SetSpeed(1.0);
 655   m_processInfo->SetTempo(1.0);
 656   m_processInfo->SetFrameAdvance(false);
 657
 658   CreatePlayers();
 659
 660   m_displayLost = false;
 661   m_error = false;
 662   m_bCloseRequest = false;
 663   CServiceBroker::GetWinSystem()->Register(this);
 664 }
 665
 666 CVideoPlayer::~CVideoPlayer()
 667 {
 668   CServiceBroker::GetWinSystem()->Unregister(this);
 669
 670   CloseFile();
 671   DestroyPlayers();
 672
 673   while (m_outboundEvents->IsProcessing())
 674   {
 675     CThread::Sleep(10ms);
 676   }
 677 }
 678
 679 bool CVideoPlayer::OpenFile(const CFileItem& file, const CPlayerOptions &options)
 680 {
 681   CLog::Log(LOGINFO, "VideoPlayer::OpenFile: {}", CURL::GetRedacted(file.GetPath()));
 682
 683   if (IsRunning())
 684   {
 685     CDVDMsgOpenFile::FileParams params;
 686     params.m_item = file;
 687     params.m_options = options;
 688     params.m_item.SetMimeTypeForInternetFile();
 689     m_messenger.Put(std::make_shared<CDVDMsgOpenFile>(params), 1);
 690
 691     return true;
 692   }
 693
 694   m_item = file;
 695   m_playerOptions = options;
 696
 697   m_processInfo->SetPlayTimes(0,0,0,0);
 698   m_bAbortRequest = false;
 699   m_error = false;
 700   m_bCloseRequest = false;
 701   m_renderManager.PreInit();
 702
 703   Create();
 704   m_messenger.Init();
 705
 706   m_callback.OnPlayBackStarted(m_item);
 707
 708   return true;
 709 }
 710
 711 bool CVideoPlayer::CloseFile(bool reopen)
 712 {
 713   CLog::Log(LOGINFO, "CVideoPlayer::CloseFile()");
 714
 715   // set the abort request so that other threads can finish up
 716   m_bAbortRequest = true;
 717   m_bCloseRequest = true;
 718
 719   // tell demuxer to abort
 720   if(m_pDemuxer)
 721     m_pDemuxer->Abort();
 722
 723   if(m_pSubtitleDemuxer)
 724     m_pSubtitleDemuxer->Abort();
 725
 726   if(m_pInputStream)
 727     m_pInputStream->Abort();
 728
 729   m_renderManager.UnInit();
 730
 731   CLog::Log(LOGINFO, "VideoPlayer: waiting for threads to exit");
 732
 733   // wait for the main thread to finish up
 734   // since this main thread cleans up all other resources and threads
 735   // we are done after the StopThread call
 736   {
 737     CSingleExit exitlock(CServiceBroker::GetWinSystem()->GetGfxContext());
 738     StopThread();
 739   }
 740
 741   m_Edl.Clear();
 742   CServiceBroker::GetDataCacheCore().Reset();
 743
 744   m_HasVideo = false;
 745   m_HasAudio = false;
 746
 747   CLog::Log(LOGINFO, "VideoPlayer: finished waiting");
 748   return true;
 749 }
 750
 751 bool CVideoPlayer::IsPlaying() const
 752 {
 753   return !m_bStop;
 754 }
 755
 756 void CVideoPlayer::OnStartup()
 757 {
 758   m_CurrentVideo.Clear();
 759   m_CurrentAudio.Clear();
 760   m_CurrentSubtitle.Clear();
 761   m_CurrentTeletext.Clear();
 762   m_CurrentRadioRDS.Clear();
 763   m_CurrentAudioID3.Clear();
 764
 765   UTILS::FONT::ClearTemporaryFonts();
 766 }
 767
 768 bool CVideoPlayer::OpenInputStream()
 769 {
 770   if (m_pInputStream.use_count() > 1)
 771     throw std::runtime_error("m_pInputStream reference count is greater than 1");
 772   m_pInputStream.reset();
 773
 774   CLog::Log(LOGINFO, "Creating InputStream");
 775
 776   m_pInputStream = CDVDFactoryInputStream::CreateInputStream(this, m_item, true);
 777   if (m_pInputStream == nullptr)
 778   {
 779     CLog::Log(LOGERROR, "CVideoPlayer::OpenInputStream - unable to create input stream for [{}]",
 780               CURL::GetRedacted(m_item.GetPath()));
 781     return false;
 782   }
 783
 784   if (!m_pInputStream->Open())
 785   {
 786     CLog::Log(LOGERROR, "CVideoPlayer::OpenInputStream - error opening [{}]",
 787               CURL::GetRedacted(m_item.GetPath()));
 788     return false;
 789   }
 790
 791   // find any available external subtitles for non dvd files
 792   if (!m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD) &&
 793       !m_pInputStream->IsStreamType(DVDSTREAM_TYPE_PVRMANAGER))
 794   {
 795     // find any available external subtitles
 796     std::vector<std::string> filenames;
 797
 798     if (!URIUtils::IsUPnP(m_item.GetPath()))
 799       CUtil::ScanForExternalSubtitles(m_item.GetDynPath(), filenames);
 800
 801     // load any subtitles from file item
 802     std::string key("subtitle:1");
 803     for (unsigned s = 1; m_item.HasProperty(key); key = StringUtils::Format("subtitle:{}", ++s))
 804       filenames.push_back(m_item.GetProperty(key).asString());
 805
 806     for (unsigned int i=0;i<filenames.size();i++)
 807     {
 808       // if vobsub subtitle:
 809       if (URIUtils::HasExtension(filenames[i], ".idx"))
 810       {
 811         std::string strSubFile;
 812         if (CUtil::FindVobSubPair( filenames, filenames[i], strSubFile))
 813           AddSubtitleFile(filenames[i], strSubFile);
 814       }
 815       else
 816       {
 817         if (!CUtil::IsVobSub(filenames, filenames[i] ))
 818         {
 819           AddSubtitleFile(filenames[i]);
 820         }
 821       }
 822     } // end loop over all subtitle files
 823   }
 824
 825   m_clock.Reset();
 826   m_dvd.Clear();
 827
 828   return true;
 829 }
 830
 831 bool CVideoPlayer::OpenDemuxStream()
 832 {
 833   CloseDemuxer();
 834
 835   CLog::Log(LOGINFO, "Creating Demuxer");
 836
 837   int attempts = 10;
 838   while (!m_bStop && attempts-- > 0)
 839   {
 840     m_pDemuxer.reset(CDVDFactoryDemuxer::CreateDemuxer(m_pInputStream));
 841     if(!m_pDemuxer && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_PVRMANAGER))
 842     {
 843       continue;
 844     }
 845     else if(!m_pDemuxer && m_pInputStream->NextStream() != CDVDInputStream::NEXTSTREAM_NONE)
 846     {
 847       CLog::Log(LOGDEBUG, "{} - New stream available from input, retry open", __FUNCTION__);
 848       continue;
 849     }
 850     break;
 851   }
 852
 853   if (!m_pDemuxer)
 854   {
 855     CLog::Log(LOGERROR, "{} - Error creating demuxer", __FUNCTION__);
 856     return false;
 857   }
 858
 859   m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX);
 860   m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_NAV);
 861   m_SelectionStreams.Update(m_pInputStream, m_pDemuxer.get());
 862   m_pDemuxer->GetPrograms(m_programs);
 863   UpdateContent();
 864   m_demuxerSpeed = DVD_PLAYSPEED_NORMAL;
 865   m_processInfo->SetStateRealtime(false);
 866
 867   int64_t len = m_pInputStream->GetLength();
 868   int64_t tim = m_pDemuxer->GetStreamLength();
 869   if (len > 0 && tim > 0)
 870     m_pInputStream->SetReadRate(static_cast<uint32_t>(len * 1000 / tim));
 871
 872   m_offset_pts = 0;
 873
 874   return true;
 875 }
 876
 877 void CVideoPlayer::CloseDemuxer()
 878 {
 879   m_pDemuxer.reset();
 880   m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX);
 881
 882   CServiceBroker::GetDataCacheCore().SignalAudioInfoChange();
 883   CServiceBroker::GetDataCacheCore().SignalVideoInfoChange();
 884   CServiceBroker::GetDataCacheCore().SignalSubtitleInfoChange();
 885 }
 886
 887 void CVideoPlayer::OpenDefaultStreams(bool reset)
 888 {
 889   // if input stream dictate, we will open later
 890   if (m_dvd.iSelectedAudioStream >= 0 ||
 891       m_dvd.iSelectedSPUStream >= 0)
 892     return;
 893
 894   bool valid;
 895
 896   // open video stream
 897   valid   = false;
 898
 899   PredicateVideoFilter vf(m_processInfo->GetVideoSettings().m_VideoStream);
 900   for (const auto &stream : m_SelectionStreams.Get(STREAM_VIDEO, vf))
 901   {
 902     if (OpenStream(m_CurrentVideo, stream.demuxerId, stream.id, stream.source, reset))
 903     {
 904       valid = true;
 905       break;
 906     }
 907   }
 908   if (!valid)
 909   {
 910     CloseStream(m_CurrentVideo, true);
 911     m_processInfo->ResetVideoCodecInfo();
 912   }
 913
 914   // open audio stream
 915   valid = false;
 916   if (!m_playerOptions.videoOnly)
 917   {
 918     PredicateAudioFilter af(m_processInfo->GetVideoSettings().m_AudioStream, m_playerOptions.preferStereo);
 919     for (const auto &stream : m_SelectionStreams.Get(STREAM_AUDIO, af))
 920     {
 921       if(OpenStream(m_CurrentAudio, stream.demuxerId, stream.id, stream.source, reset))
 922       {
 923         valid = true;
 924         break;
 925       }
 926     }
 927   }
 928
 929   if(!valid)
 930   {
 931     CloseStream(m_CurrentAudio, true);
 932     m_processInfo->ResetAudioCodecInfo();
 933   }
 934
 935   // enable  or disable subtitles
 936   bool visible = m_processInfo->GetVideoSettings().m_SubtitleOn;
 937
 938   // open subtitle stream
 939   SelectionStream as = m_SelectionStreams.Get(STREAM_AUDIO, GetAudioStream());
 940   PredicateSubtitlePriority psp(as.language,
 941                                 m_processInfo->GetVideoSettings().m_SubtitleStream,
 942                                 m_processInfo->GetVideoSettings().m_SubtitleOn);
 943   valid = false;
 944   // We need to close CC subtitles to avoid conflicts with external sub stream
 945   if (m_CurrentSubtitle.source == STREAM_SOURCE_VIDEOMUX)
 946     CloseStream(m_CurrentSubtitle, false);
 947
 948   for (const auto &stream : m_SelectionStreams.Get(STREAM_SUBTITLE, psp))
 949   {
 950     if (OpenStream(m_CurrentSubtitle, stream.demuxerId, stream.id, stream.source))
 951     {
 952       valid = true;
 953       if(!psp.relevant(stream))
 954         visible = false;
 955       else if(stream.flags & StreamFlags::FLAG_FORCED)
 956         visible = true;
 957       break;
 958     }
 959   }
 960   if(!valid)
 961     CloseStream(m_CurrentSubtitle, false);
 962
 963   // only set subtitle visibility if state not stored by dvd navigator, because navigator will restore it (if visible)
 964   if (!std::dynamic_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream) ||
 965       m_playerOptions.state.empty())
 966   {
 967     // SetEnableStream only if not visible, when visible OpenStream already implied that stream is enabled
 968     if (valid && !visible)
 969       SetEnableStream(m_CurrentSubtitle, false);
 970
 971     SetSubtitleVisibleInternal(visible);
 972   }
 973
 974   // open teletext stream
 975   valid   = false;
 976   for (const auto &stream : m_SelectionStreams.Get(STREAM_TELETEXT))
 977   {
 978     if (OpenStream(m_CurrentTeletext, stream.demuxerId, stream.id, stream.source))
 979     {
 980       valid = true;
 981       break;
 982     }
 983   }
 984   if(!valid)
 985     CloseStream(m_CurrentTeletext, false);
 986
 987   // open RDS stream
 988   valid   = false;
 989   for (const auto &stream : m_SelectionStreams.Get(STREAM_RADIO_RDS))
 990   {
 991     if (OpenStream(m_CurrentRadioRDS, stream.demuxerId, stream.id, stream.source))
 992     {
 993       valid = true;
 994       break;
 995     }
 996   }
 997   if(!valid)
 998     CloseStream(m_CurrentRadioRDS, false);
 999
1000   // open ID3 stream
1001   valid = false;
1002   for (const auto& stream : m_SelectionStreams.Get(STREAM_AUDIO_ID3))
1003   {
1004     if (OpenStream(m_CurrentAudioID3, stream.demuxerId, stream.id, stream.source))
1005     {
1006       valid = true;
1007       break;
1008     }
1009   }
1010   if (!valid)
1011     CloseStream(m_CurrentAudioID3, false);
1012
1013   // disable demux streams
1014   if (NETWORK::IsRemote(m_item) && m_pDemuxer)
1015   {
1016     for (auto &stream : m_SelectionStreams.m_Streams)
1017     {
1018       if (STREAM_SOURCE_MASK(stream.source) == STREAM_SOURCE_DEMUX)
1019       {
1020         if (stream.id != m_CurrentVideo.id && stream.id != m_CurrentAudio.id &&
1021             stream.id != m_CurrentSubtitle.id && stream.id != m_CurrentTeletext.id &&
1022             stream.id != m_CurrentRadioRDS.id && stream.id != m_CurrentAudioID3.id)
1023         {
1024           m_pDemuxer->EnableStream(stream.demuxerId, stream.id, false);
1025         }
1026       }
1027     }
1028   }
1029 }
1030
1031 bool CVideoPlayer::ReadPacket(DemuxPacket*& packet, CDemuxStream*& stream)
1032 {
1033
1034   // check if we should read from subtitle demuxer
1035   if (m_pSubtitleDemuxer && m_VideoPlayerSubtitle->AcceptsData())
1036   {
1037     packet = m_pSubtitleDemuxer->Read();
1038
1039     if(packet)
1040     {
1041       UpdateCorrection(packet, m_offset_pts);
1042       if(packet->iStreamId < 0)
1043         return true;
1044
1045       stream = m_pSubtitleDemuxer->GetStream(packet->demuxerId, packet->iStreamId);
1046       if (!stream)
1047       {
1048         CLog::Log(LOGERROR, "{} - Error demux packet doesn't belong to a valid stream",
1049                   __FUNCTION__);
1050         return false;
1051       }
1052       if (stream->source == STREAM_SOURCE_NONE)
1053       {
1054         m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX_SUB);
1055         m_SelectionStreams.Update(NULL, m_pSubtitleDemuxer.get());
1056         UpdateContent();
1057       }
1058       return true;
1059     }
1060   }
1061
1062   // read a data frame from stream.
1063   if (m_pDemuxer)
1064     packet = m_pDemuxer->Read();
1065
1066   if (packet)
1067   {
1068     // stream changed, update and open defaults
1069     if (packet->iStreamId == DMX_SPECIALID_STREAMCHANGE)
1070     {
1071       m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX);
1072       m_SelectionStreams.Update(m_pInputStream, m_pDemuxer.get());
1073       m_pDemuxer->GetPrograms(m_programs);
1074       UpdateContent();
1075       OpenDefaultStreams(false);
1076
1077       // reevaluate HasVideo/Audio, we may have switched from/to a radio channel
1078       if(m_CurrentVideo.id < 0)
1079         m_HasVideo = false;
1080       if(m_CurrentAudio.id < 0)
1081         m_HasAudio = false;
1082
1083       return true;
1084     }
1085
1086     UpdateCorrection(packet, m_offset_pts);
1087
1088     if(packet->iStreamId < 0)
1089       return true;
1090
1091     if(m_pDemuxer)
1092     {
1093       stream = m_pDemuxer->GetStream(packet->demuxerId, packet->iStreamId);
1094       if (!stream)
1095       {
1096         CLog::Log(LOGERROR, "{} - Error demux packet doesn't belong to a valid stream",
1097                   __FUNCTION__);
1098         return false;
1099       }
1100       if(stream->source == STREAM_SOURCE_NONE)
1101       {
1102         m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX);
1103         m_SelectionStreams.Update(m_pInputStream, m_pDemuxer.get());
1104         UpdateContent();
1105       }
1106     }
1107     return true;
1108   }
1109   return false;
1110 }
1111
1112 bool CVideoPlayer::IsValidStream(const CCurrentStream& stream)
1113 {
1114   if(stream.id<0)
1115     return true; // we consider non selected as valid
1116
1117   int source = STREAM_SOURCE_MASK(stream.source);
1118   if(source == STREAM_SOURCE_TEXT)
1119     return true;
1120   if (source == STREAM_SOURCE_DEMUX_SUB)
1121   {
1122     CDemuxStream* st = m_pSubtitleDemuxer->GetStream(stream.demuxerId, stream.id);
1123     if(st == NULL || st->disabled)
1124       return false;
1125     if(st->type != stream.type)
1126       return false;
1127     return true;
1128   }
1129   if (source == STREAM_SOURCE_DEMUX)
1130   {
1131     CDemuxStream* st = m_pDemuxer->GetStream(stream.demuxerId, stream.id);
1132     if(st == NULL || st->disabled)
1133       return false;
1134     if(st->type != stream.type)
1135       return false;
1136
1137     if (m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
1138     {
1139       if (stream.type == STREAM_AUDIO && st->dvdNavId != m_dvd.iSelectedAudioStream)
1140         return false;
1141       if(stream.type == STREAM_SUBTITLE && st->dvdNavId != m_dvd.iSelectedSPUStream)
1142         return false;
1143     }
1144
1145     return true;
1146   }
1147   if (source == STREAM_SOURCE_VIDEOMUX)
1148   {
1149     CDemuxStream* st = m_pCCDemuxer->GetStream(stream.id);
1150     if (st == NULL || st->disabled)
1151       return false;
1152     if (st->type != stream.type)
1153       return false;
1154     return true;
1155   }
1156
1157   return false;
1158 }
1159
1160 bool CVideoPlayer::IsBetterStream(const CCurrentStream& current, CDemuxStream* stream)
1161 {
1162   // Do not reopen non-video streams if we're in video-only mode
1163   if (m_playerOptions.videoOnly && current.type != STREAM_VIDEO)
1164     return false;
1165
1166   if(stream->disabled)
1167     return false;
1168
1169   if (m_pInputStream && (m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD) ||
1170                          m_pInputStream->IsStreamType(DVDSTREAM_TYPE_BLURAY)))
1171   {
1172     int source_type;
1173
1174     source_type = STREAM_SOURCE_MASK(current.source);
1175     if (source_type != STREAM_SOURCE_DEMUX &&
1176         source_type != STREAM_SOURCE_NONE)
1177       return false;
1178
1179     source_type = STREAM_SOURCE_MASK(stream->source);
1180     if(source_type != STREAM_SOURCE_DEMUX ||
1181        stream->type != current.type ||
1182        stream->uniqueId == current.id)
1183       return false;
1184
1185     if(current.type == STREAM_AUDIO && stream->dvdNavId == m_dvd.iSelectedAudioStream)
1186       return true;
1187     if(current.type == STREAM_SUBTITLE && stream->dvdNavId == m_dvd.iSelectedSPUStream)
1188       return true;
1189     if(current.type == STREAM_VIDEO && current.id < 0)
1190       return true;
1191   }
1192   else
1193   {
1194     if(stream->source == current.source &&
1195        stream->uniqueId == current.id &&
1196        stream->demuxerId == current.demuxerId)
1197       return false;
1198
1199     if(stream->type != current.type)
1200       return false;
1201
1202     if(current.type == STREAM_SUBTITLE)
1203       return false;
1204
1205     if(current.id < 0)
1206       return true;
1207   }
1208   return false;
1209 }
1210
1211 void CVideoPlayer::CheckBetterStream(CCurrentStream& current, CDemuxStream* stream)
1212 {
1213   IDVDStreamPlayer* player = GetStreamPlayer(current.player);
1214   if (!IsValidStream(current) && (player == NULL || player->IsStalled()))
1215     CloseStream(current, true);
1216
1217   if (IsBetterStream(current, stream))
1218     OpenStream(current, stream->demuxerId, stream->uniqueId, stream->source);
1219 }
1220
1221 void CVideoPlayer::Prepare()
1222 {
1223   CFFmpegLog::SetLogLevel(1);
1224   SetPlaySpeed(DVD_PLAYSPEED_NORMAL);
1225   m_processInfo->SetSpeed(1.0);
1226   m_processInfo->SetTempo(1.0);
1227   m_processInfo->SetFrameAdvance(false);
1228   m_State.Clear();
1229   m_CurrentVideo.hint.Clear();
1230   m_CurrentAudio.hint.Clear();
1231   m_CurrentSubtitle.hint.Clear();
1232   m_CurrentTeletext.hint.Clear();
1233   m_CurrentRadioRDS.hint.Clear();
1234   m_CurrentAudioID3.hint.Clear();
1235   m_SpeedState.Reset(DVD_NOPTS_VALUE);
1236   m_offset_pts = 0;
1237   m_CurrentAudio.lastdts = DVD_NOPTS_VALUE;
1238   m_CurrentVideo.lastdts = DVD_NOPTS_VALUE;
1239
1240   IPlayerCallback *cb = &m_callback;
1241   CFileItem fileItem = m_item;
1242   m_outboundEvents->Submit([=]() {
1243     cb->RequestVideoSettings(fileItem);
1244   });
1245
1246   if (!OpenInputStream())
1247   {
1248     m_bAbortRequest = true;
1249     m_error = true;
1250     return;
1251   }
1252
1253   bool discStateRestored = false;
1254   if (std::shared_ptr<CDVDInputStream::IMenus> ptr = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream))
1255   {
1256     CLog::Log(LOGINFO, "VideoPlayer: playing a file with menu's");
1257
1258     if (!m_playerOptions.state.empty())
1259     {
1260       discStateRestored = ptr->SetState(m_playerOptions.state);
1261     }
1262     else if(std::shared_ptr<CDVDInputStreamNavigator> nav = std::dynamic_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream))
1263     {
1264       nav->EnableSubtitleStream(m_processInfo->GetVideoSettings().m_SubtitleOn);
1265     }
1266   }
1267
1268   if (!OpenDemuxStream())
1269   {
1270     m_bAbortRequest = true;
1271     m_error = true;
1272     return;
1273   }
1274   // give players a chance to reconsider now codecs are known
1275   CreatePlayers();
1276
1277   if (!discStateRestored)
1278     OpenDefaultStreams();
1279
1280   /*
1281    * Check to see if the demuxer should start at something other than time 0. This will be the case
1282    * if there was a start time specified as part of the "Start from where last stopped" (aka
1283    * auto-resume) feature or if there is an EDL cut or commercial break that starts at time 0.
1284    */
1285   std::chrono::milliseconds starttime = 0ms;
1286   if (m_playerOptions.starttime > 0 || m_playerOptions.startpercent > 0)
1287   {
1288     if (m_playerOptions.startpercent > 0 && m_pDemuxer)
1289     {
1290       std::chrono::milliseconds playerStartTime =
1291           std::chrono::milliseconds(static_cast<int>((static_cast<double>(
1292               m_pDemuxer->GetStreamLength() * (m_playerOptions.startpercent / 100.0)))));
1293       starttime = m_Edl.GetTimeAfterRestoringCuts(playerStartTime);
1294     }
1295     else
1296     {
1297       starttime =
1298           m_Edl.GetTimeAfterRestoringCuts(std::chrono::duration_cast<std::chrono::milliseconds>(
1299               std::chrono::seconds(static_cast<int>(m_playerOptions.starttime))));
1300     }
1301     CLog::Log(LOGDEBUG, "{} - Start position set to last stopped position: {}", __FUNCTION__,
1302               starttime.count());
1303   }
1304   else
1305   {
1306     const auto hasEdit = m_Edl.InEdit(starttime);
1307     if (hasEdit)
1308     {
1309       const auto& edit = hasEdit.value();
1310       // save last edit times
1311       m_Edl.SetLastEditTime(edit->start);
1312       m_Edl.SetLastEditActionType(edit->action);
1313
1314       if (edit->action == EDL::Action::CUT)
1315       {
1316         starttime = edit->end;
1317         CLog::Log(LOGDEBUG, "{} - Start position set to end of first cut: {}", __FUNCTION__,
1318                   starttime.count());
1319       }
1320       else if (edit->action == EDL::Action::COMM_BREAK)
1321       {
1322         if (m_SkipCommercials)
1323         {
1324           starttime = edit->end;
1325           CLog::Log(LOGDEBUG, "{} - Start position set to end of first commercial break: {}",
1326                     __FUNCTION__, starttime.count());
1327         }
1328
1329         const std::shared_ptr<CAdvancedSettings> advancedSettings =
1330             CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
1331         if (advancedSettings && advancedSettings->m_EdlDisplayCommbreakNotifications)
1332         {
1333           const std::string timeString =
1334               StringUtils::SecondsToTimeString(edit->end.count(), TIME_FORMAT_MM_SS);
1335           CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(25011), timeString);
1336         }
1337       }
1338     }
1339   }
1340
1341   if (starttime > 0ms)
1342   {
1343     double startpts = DVD_NOPTS_VALUE;
1344     if (m_pDemuxer)
1345     {
1346       if (m_pDemuxer->SeekTime(starttime.count(), true, &startpts))
1347       {
1348         FlushBuffers(starttime.count() / 1000 * AV_TIME_BASE, true, true);
1349         CLog::Log(LOGDEBUG, "{} - starting demuxer from: {}", __FUNCTION__, starttime.count());
1350       }
1351       else
1352         CLog::Log(LOGDEBUG, "{} - failed to start demuxing from: {}", __FUNCTION__,
1353                   starttime.count());
1354     }
1355
1356     if (m_pSubtitleDemuxer)
1357     {
1358       if (m_pSubtitleDemuxer->SeekTime(starttime.count(), true, &startpts))
1359         CLog::Log(LOGDEBUG, "{} - starting subtitle demuxer from: {}", __FUNCTION__,
1360                   starttime.count());
1361       else
1362         CLog::Log(LOGDEBUG, "{} - failed to start subtitle demuxing from: {}", __FUNCTION__,
1363                   starttime.count());
1364     }
1365
1366     m_clock.Discontinuity(DVD_MSEC_TO_TIME(starttime.count()));
1367   }
1368
1369   UpdatePlayState(0);
1370
1371   SetCaching(CACHESTATE_FLUSH);
1372 }
1373
1374 void CVideoPlayer::Process()
1375 {
1376   // Try to resolve the correct mime type. This can take some time, for example if a requested
1377   // item is located at a slow/not reachable remote source. So, do mime type detection in vp worker
1378   // thread, not directly when initalizing the player to keep GUI responsible.
1379   m_item.SetMimeTypeForInternetFile();
1380
1381   CServiceBroker::GetWinSystem()->RegisterRenderLoop(this);
1382
1383   Prepare();
1384
1385   while (!m_bAbortRequest)
1386   {
1387     // check display lost
1388     if (m_displayLost)
1389     {
1390       CThread::Sleep(50ms);
1391       continue;
1392     }
1393
1394     // check if in an edit (cut or commercial break) that should be automatically skipped
1395     CheckAutoSceneSkip();
1396
1397     // handle messages send to this thread, like seek or demuxer reset requests
1398     HandleMessages();
1399
1400     if (m_bAbortRequest)
1401       break;
1402
1403     // should we open a new input stream?
1404     if (!m_pInputStream)
1405     {
1406       if (OpenInputStream() == false)
1407       {
1408         m_bAbortRequest = true;
1409         break;
1410       }
1411     }
1412
1413     // should we open a new demuxer?
1414     if (!m_pDemuxer)
1415     {
1416       if (m_pInputStream->NextStream() == CDVDInputStream::NEXTSTREAM_NONE)
1417         break;
1418
1419       if (m_pInputStream->IsEOF())
1420         break;
1421
1422       if (OpenDemuxStream() == false)
1423       {
1424         m_bAbortRequest = true;
1425         break;
1426       }
1427
1428       // on channel switch we don't want to close stream players at this
1429       // time. we'll get the stream change event later
1430       if (!m_pInputStream->IsStreamType(DVDSTREAM_TYPE_PVRMANAGER) ||
1431           !m_SelectionStreams.m_Streams.empty())
1432         OpenDefaultStreams();
1433
1434       UpdatePlayState(0);
1435     }
1436
1437     // handle eventual seeks due to playspeed
1438     HandlePlaySpeed();
1439
1440     // update player state
1441     UpdatePlayState(200);
1442
1443     // make sure we run subtitle process here
1444     m_VideoPlayerSubtitle->Process(m_clock.GetClock() + m_State.time_offset - m_VideoPlayerVideo->GetSubtitleDelay(), m_State.time_offset);
1445
1446     // tell demuxer if we want to fill buffers
1447     if (m_demuxerSpeed != DVD_PLAYSPEED_PAUSE)
1448     {
1449       int audioLevel = 90;
1450       int videoLevel = 90;
1451       bool fillBuffer = false;
1452       if (m_CurrentAudio.id >= 0)
1453         audioLevel = m_VideoPlayerAudio->GetLevel();
1454       if (m_CurrentVideo.id >= 0)
1455         videoLevel = m_processInfo->GetLevelVQ();
1456       if (videoLevel < 85 && audioLevel < 85)
1457       {
1458         fillBuffer = true;
1459       }
1460       if (m_pDemuxer)
1461         m_pDemuxer->FillBuffer(fillBuffer);
1462     }
1463
1464     // if the queues are full, no need to read more
1465     if ((!m_VideoPlayerAudio->AcceptsData() && m_CurrentAudio.id >= 0) ||
1466         (!m_VideoPlayerVideo->AcceptsData() && m_CurrentVideo.id >= 0))
1467     {
1468       if (m_playSpeed == DVD_PLAYSPEED_PAUSE &&
1469           m_demuxerSpeed != DVD_PLAYSPEED_PAUSE)
1470       {
1471         if (m_pDemuxer)
1472           m_pDemuxer->SetSpeed(DVD_PLAYSPEED_PAUSE);
1473         m_demuxerSpeed = DVD_PLAYSPEED_PAUSE;
1474       }
1475       CThread::Sleep(10ms);
1476       continue;
1477     }
1478
1479     // adjust demuxer speed; some rtsp servers wants to know for i.e. ff
1480     // delay pause until queue is full
1481     if (m_playSpeed != DVD_PLAYSPEED_PAUSE &&
1482         m_demuxerSpeed != m_playSpeed)
1483     {
1484       if (m_pDemuxer)
1485         m_pDemuxer->SetSpeed(m_playSpeed);
1486       m_demuxerSpeed = m_playSpeed;
1487     }
1488
1489     DemuxPacket* pPacket = NULL;
1490     CDemuxStream *pStream = NULL;
1491     ReadPacket(pPacket, pStream);
1492     if (pPacket && !pStream)
1493     {
1494       /* probably a empty packet, just free it and move on */
1495       CDVDDemuxUtils::FreeDemuxPacket(pPacket);
1496       continue;
1497     }
1498
1499     if (!pPacket)
1500     {
1501       // when paused, demuxer could be be returning empty
1502       if (m_playSpeed == DVD_PLAYSPEED_PAUSE)
1503         continue;
1504
1505       // check for a still frame state
1506       if (std::shared_ptr<CDVDInputStream::IMenus> pStream = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream))
1507       {
1508         // stills will be skipped
1509         if(m_dvd.state == DVDSTATE_STILL)
1510         {
1511           if (m_dvd.iDVDStillTime > 0ms)
1512           {
1513             const auto now = std::chrono::steady_clock::now();
1514             const auto duration = now - m_dvd.iDVDStillStartTime;
1515
1516             if (duration >= m_dvd.iDVDStillTime)
1517             {
1518               m_dvd.iDVDStillTime = 0ms;
1519               m_dvd.iDVDStillStartTime = {};
1520               m_dvd.state = DVDSTATE_NORMAL;
1521               pStream->SkipStill();
1522               continue;
1523             }
1524           }
1525         }
1526       }
1527
1528       // if there is another stream available, reopen demuxer
1529       CDVDInputStream::ENextStream next = m_pInputStream->NextStream();
1530       if(next == CDVDInputStream::NEXTSTREAM_OPEN)
1531       {
1532         CloseDemuxer();
1533
1534         SetCaching(CACHESTATE_DONE);
1535         CLog::Log(LOGINFO, "VideoPlayer: next stream, wait for old streams to be finished");
1536         CloseStream(m_CurrentAudio, true);
1537         CloseStream(m_CurrentVideo, true);
1538
1539         m_CurrentAudio.Clear();
1540         m_CurrentVideo.Clear();
1541         m_CurrentSubtitle.Clear();
1542         continue;
1543       }
1544
1545       // input stream asked us to just retry
1546       if(next == CDVDInputStream::NEXTSTREAM_RETRY)
1547       {
1548         CThread::Sleep(100ms);
1549         continue;
1550       }
1551
1552       if (m_CurrentVideo.inited)
1553       {
1554         m_VideoPlayerVideo->SendMessage(std::make_shared<CDVDMsg>(CDVDMsg::VIDEO_DRAIN));
1555       }
1556
1557       m_CurrentAudio.inited = false;
1558       m_CurrentVideo.inited = false;
1559       m_CurrentSubtitle.inited = false;
1560       m_CurrentTeletext.inited = false;
1561       m_CurrentRadioRDS.inited = false;
1562       m_CurrentAudioID3.inited = false;
1563
1564       // if we are caching, start playing it again
1565       SetCaching(CACHESTATE_DONE);
1566
1567       // while players are still playing, keep going to allow seekbacks
1568       if (m_VideoPlayerAudio->HasData() ||
1569           m_VideoPlayerVideo->HasData())
1570       {
1571         CThread::Sleep(100ms);
1572         continue;
1573       }
1574
1575       if (!m_pInputStream->IsEOF())
1576         CLog::Log(LOGINFO, "{} - eof reading from demuxer", __FUNCTION__);
1577
1578       break;
1579     }
1580
1581     // see if we can find something better to play
1582     CheckBetterStream(m_CurrentAudio,    pStream);
1583     CheckBetterStream(m_CurrentVideo,    pStream);
1584     CheckBetterStream(m_CurrentSubtitle, pStream);
1585     CheckBetterStream(m_CurrentTeletext, pStream);
1586     CheckBetterStream(m_CurrentRadioRDS, pStream);
1587     CheckBetterStream(m_CurrentAudioID3, pStream);
1588
1589     // demux video stream
1590     if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_SUBTITLES_PARSECAPTIONS) && CheckIsCurrent(m_CurrentVideo, pStream, pPacket))
1591     {
1592       if (m_pCCDemuxer)
1593       {
1594         bool first = true;
1595         while (!m_bAbortRequest)
1596         {
1597           DemuxPacket *pkt = m_pCCDemuxer->Read(first ? pPacket : NULL);
1598           if (!pkt)
1599             break;
1600
1601           first = false;
1602           if (m_pCCDemuxer->GetNrOfStreams() != m_SelectionStreams.CountTypeOfSource(STREAM_SUBTITLE, STREAM_SOURCE_VIDEOMUX))
1603           {
1604             m_SelectionStreams.Clear(STREAM_SUBTITLE, STREAM_SOURCE_VIDEOMUX);
1605             m_SelectionStreams.Update(NULL, m_pCCDemuxer.get(), "");
1606             UpdateContent();
1607             OpenDefaultStreams(false);
1608           }
1609           CDemuxStream *pSubStream = m_pCCDemuxer->GetStream(pkt->iStreamId);
1610           if (pSubStream && m_CurrentSubtitle.id == pkt->iStreamId && m_CurrentSubtitle.source == STREAM_SOURCE_VIDEOMUX)
1611             ProcessSubData(pSubStream, pkt);
1612           else
1613             CDVDDemuxUtils::FreeDemuxPacket(pkt);
1614         }
1615       }
1616     }
1617
1618     if (IsInMenuInternal())
1619     {
1620       if (std::shared_ptr<CDVDInputStream::IMenus> menu = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream))
1621       {
1622         double correction = menu->GetTimeStampCorrection();
1623         if (pPacket->dts != DVD_NOPTS_VALUE && pPacket->dts > correction)
1624           pPacket->dts -= correction;
1625         if (pPacket->pts != DVD_NOPTS_VALUE && pPacket->pts > correction)
1626           pPacket->pts -= correction;
1627       }
1628       if (m_dvd.syncClock)
1629       {
1630         m_clock.Discontinuity(pPacket->dts);
1631         m_dvd.syncClock = false;
1632       }
1633     }
1634
1635     // process the packet
1636     ProcessPacket(pStream, pPacket);
1637   }
1638 }
1639
1640 bool CVideoPlayer::CheckIsCurrent(const CCurrentStream& current,
1641                                   CDemuxStream* stream,
1642                                   DemuxPacket* pkg)
1643 {
1644   if(current.id == pkg->iStreamId &&
1645      current.demuxerId == stream->demuxerId &&
1646      current.source == stream->source &&
1647      current.type == stream->type)
1648     return true;
1649   else
1650     return false;
1651 }
1652
1653 void CVideoPlayer::ProcessPacket(CDemuxStream* pStream, DemuxPacket* pPacket)
1654 {
1655   // process packet if it belongs to selected stream.
1656   // for dvd's don't allow automatic opening of streams*/
1657
1658   if (CheckIsCurrent(m_CurrentAudio, pStream, pPacket))
1659     ProcessAudioData(pStream, pPacket);
1660   else if (CheckIsCurrent(m_CurrentVideo, pStream, pPacket))
1661     ProcessVideoData(pStream, pPacket);
1662   else if (CheckIsCurrent(m_CurrentSubtitle, pStream, pPacket))
1663     ProcessSubData(pStream, pPacket);
1664   else if (CheckIsCurrent(m_CurrentTeletext, pStream, pPacket))
1665     ProcessTeletextData(pStream, pPacket);
1666   else if (CheckIsCurrent(m_CurrentRadioRDS, pStream, pPacket))
1667     ProcessRadioRDSData(pStream, pPacket);
1668   else if (CheckIsCurrent(m_CurrentAudioID3, pStream, pPacket))
1669     ProcessAudioID3Data(pStream, pPacket);
1670   else
1671   {
1672     CDVDDemuxUtils::FreeDemuxPacket(pPacket); // free it since we won't do anything with it
1673   }
1674 }
1675
1676 void CVideoPlayer::CheckStreamChanges(CCurrentStream& current, CDemuxStream* stream)
1677 {
1678   if (current.stream  != (void*)stream
1679   ||  current.changes != stream->changes)
1680   {
1681     /* check so that dmuxer hints or extra data hasn't changed */
1682     /* if they have, reopen stream */
1683
1684     if (current.hint != CDVDStreamInfo(*stream, true))
1685     {
1686       m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_DEMUX);
1687       m_SelectionStreams.Update(m_pInputStream, m_pDemuxer.get());
1688       UpdateContent();
1689       OpenDefaultStreams(false);
1690     }
1691
1692     current.stream = (void*)stream;
1693     current.changes = stream->changes;
1694   }
1695 }
1696
1697 void CVideoPlayer::ProcessAudioData(CDemuxStream* pStream, DemuxPacket* pPacket)
1698 {
1699   CheckStreamChanges(m_CurrentAudio, pStream);
1700
1701   bool checkcont = CheckContinuity(m_CurrentAudio, pPacket);
1702   UpdateTimestamps(m_CurrentAudio, pPacket);
1703
1704   if (checkcont && (m_CurrentAudio.avsync == CCurrentStream::AV_SYNC_CHECK))
1705     m_CurrentAudio.avsync = CCurrentStream::AV_SYNC_NONE;
1706
1707   bool drop = false;
1708   if (CheckPlayerInit(m_CurrentAudio))
1709     drop = true;
1710
1711   /*
1712    * If CheckSceneSkip() returns true then demux point is inside an EDL cut and the packets are dropped.
1713    */
1714   if (CheckSceneSkip(m_CurrentAudio))
1715   {
1716     drop = true;
1717   }
1718   else
1719   {
1720     const auto hasEdit = m_Edl.InEdit(
1721         std::chrono::milliseconds(DVD_TIME_TO_MSEC(m_CurrentAudio.dts + m_offset_pts)));
1722     if (hasEdit && hasEdit.value()->action == EDL::Action::MUTE)
1723       drop = true;
1724   }
1725
1726   m_VideoPlayerAudio->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1727
1728   if (!drop)
1729     m_CurrentAudio.packets++;
1730 }
1731
1732 void CVideoPlayer::ProcessVideoData(CDemuxStream* pStream, DemuxPacket* pPacket)
1733 {
1734   CheckStreamChanges(m_CurrentVideo, pStream);
1735   bool checkcont = false;
1736
1737   if( pPacket->iSize != 4) //don't check the EOF_SEQUENCE of stillframes
1738   {
1739     checkcont = CheckContinuity(m_CurrentVideo, pPacket);
1740     UpdateTimestamps(m_CurrentVideo, pPacket);
1741   }
1742   if (checkcont && (m_CurrentVideo.avsync == CCurrentStream::AV_SYNC_CHECK))
1743     m_CurrentVideo.avsync = CCurrentStream::AV_SYNC_NONE;
1744
1745   bool drop = false;
1746   if (CheckPlayerInit(m_CurrentVideo))
1747     drop = true;
1748
1749   if (CheckSceneSkip(m_CurrentVideo))
1750     drop = true;
1751
1752   m_VideoPlayerVideo->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1753
1754   if (!drop)
1755     m_CurrentVideo.packets++;
1756 }
1757
1758 void CVideoPlayer::ProcessSubData(CDemuxStream* pStream, DemuxPacket* pPacket)
1759 {
1760   CheckStreamChanges(m_CurrentSubtitle, pStream);
1761
1762   UpdateTimestamps(m_CurrentSubtitle, pPacket);
1763
1764   bool drop = false;
1765   if (CheckPlayerInit(m_CurrentSubtitle))
1766     drop = true;
1767
1768   if (CheckSceneSkip(m_CurrentSubtitle))
1769     drop = true;
1770
1771   m_VideoPlayerSubtitle->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1772
1773   if(m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
1774     m_VideoPlayerSubtitle->UpdateOverlayInfo(std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream), LIBDVDNAV_BUTTON_NORMAL);
1775 }
1776
1777 void CVideoPlayer::ProcessTeletextData(CDemuxStream* pStream, DemuxPacket* pPacket)
1778 {
1779   CheckStreamChanges(m_CurrentTeletext, pStream);
1780
1781   UpdateTimestamps(m_CurrentTeletext, pPacket);
1782
1783   bool drop = false;
1784   if (CheckPlayerInit(m_CurrentTeletext))
1785     drop = true;
1786
1787   if (CheckSceneSkip(m_CurrentTeletext))
1788     drop = true;
1789
1790   m_VideoPlayerTeletext->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1791 }
1792
1793 void CVideoPlayer::ProcessRadioRDSData(CDemuxStream* pStream, DemuxPacket* pPacket)
1794 {
1795   CheckStreamChanges(m_CurrentRadioRDS, pStream);
1796
1797   UpdateTimestamps(m_CurrentRadioRDS, pPacket);
1798
1799   bool drop = false;
1800   if (CheckPlayerInit(m_CurrentRadioRDS))
1801     drop = true;
1802
1803   if (CheckSceneSkip(m_CurrentRadioRDS))
1804     drop = true;
1805
1806   m_VideoPlayerRadioRDS->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1807 }
1808
1809 void CVideoPlayer::ProcessAudioID3Data(CDemuxStream* pStream, DemuxPacket* pPacket)
1810 {
1811   CheckStreamChanges(m_CurrentAudioID3, pStream);
1812
1813   UpdateTimestamps(m_CurrentAudioID3, pPacket);
1814
1815   bool drop = false;
1816   if (CheckPlayerInit(m_CurrentAudioID3))
1817     drop = true;
1818
1819   if (CheckSceneSkip(m_CurrentAudioID3))
1820     drop = true;
1821
1822   m_VideoPlayerAudioID3->SendMessage(std::make_shared<CDVDMsgDemuxerPacket>(pPacket, drop));
1823 }
1824
1825 CacheInfo CVideoPlayer::GetCachingTimes()
1826 {
1827   CacheInfo info{};
1828
1829   if (!m_pInputStream || !m_pDemuxer)
1830     return info;
1831
1832   XFILE::SCacheStatus status;
1833   if (!m_pInputStream->GetCacheStatus(&status))
1834     return info;
1835
1836   const uint64_t& maxforward = status.maxforward;
1837   const uint64_t& cached = status.forward;
1838   const uint32_t& currate = status.currate;
1839   const uint32_t& maxrate = status.maxrate;
1840   const uint32_t& lowrate = status.lowrate;
1841
1842   int64_t length = m_pInputStream->GetLength();
1843   int64_t remain = length - m_pInputStream->Seek(0, SEEK_CUR);
1844
1845   if (length <= 0 || remain < 0)
1846     return info;
1847
1848   double queueTime = GetQueueTime();
1849   double play_sbp = DVD_MSEC_TO_TIME(m_pDemuxer->GetStreamLength()) / length;
1850   double queued = 1000.0 * queueTime / play_sbp;
1851
1852   info.level = 0.0;
1853   info.offset = (cached + queued) / length;
1854   info.time = 0.0;
1855   info.valid = true;
1856
1857   if (currate == 0)
1858     return info;
1859
1860   // estimated playback time of current cached bytes
1861   const double cacheTime = (static_cast<double>(cached) / currate) + (queueTime / 1000.0);
1862
1863   // cache level as current forward bytes / max forward bytes [0.0 - 1.0]
1864   const double cacheLevel = (maxforward > 0) ? static_cast<double>(cached) / maxforward : 0.0;
1865
1866   info.time = cacheTime;
1867
1868   if (lowrate > 0)
1869   {
1870     // buffer is full & our read rate is too low
1871     CLog::Log(LOGDEBUG, "Readrate {} was too low with {} required", lowrate, maxrate);
1872     info.level = -1.0;
1873   }
1874   else
1875     info.level = cacheLevel;
1876
1877   return info;
1878 }
1879
1880 void CVideoPlayer::HandlePlaySpeed()
1881 {
1882   const bool isInMenu = IsInMenuInternal();
1883   const bool tolerateStall =
1884       isInMenu || (m_CurrentVideo.hint.flags & StreamFlags::FLAG_STILL_IMAGES);
1885
1886   if (tolerateStall && m_caching != CACHESTATE_DONE)
1887     SetCaching(CACHESTATE_DONE);
1888
1889   if (m_caching == CACHESTATE_FULL)
1890   {
1891     CacheInfo cache = GetCachingTimes();
1892     if (cache.valid)
1893     {
1894       if (cache.level < 0.0)
1895       {
1896         CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(21454), g_localizeStrings.Get(21455));
1897         SetCaching(CACHESTATE_INIT);
1898       }
1899       // Note: Previously used cache.level >= 1 would keep video stalled
1900       // event after cache was full
1901       // Talk link: https://github.com/xbmc/xbmc/pull/23760
1902       if (cache.time > m_messageQueueTimeSize)
1903         SetCaching(CACHESTATE_INIT);
1904     }
1905     else
1906     {
1907       if ((!m_VideoPlayerAudio->AcceptsData() && m_CurrentAudio.id >= 0) ||
1908           (!m_VideoPlayerVideo->AcceptsData() && m_CurrentVideo.id >= 0))
1909         SetCaching(CACHESTATE_INIT);
1910     }
1911
1912     // if audio stream stalled, wait until demux queue filled 10%
1913     if (m_pInputStream->IsRealtime() &&
1914         (m_CurrentAudio.id < 0 || m_VideoPlayerAudio->GetLevel() > 10))
1915     {
1916       SetCaching(CACHESTATE_INIT);
1917     }
1918   }
1919
1920   if (m_caching == CACHESTATE_INIT)
1921   {
1922     // if all enabled streams have been inited we are done
1923     if ((m_CurrentVideo.id >= 0 || m_CurrentAudio.id >= 0) &&
1924         (m_CurrentVideo.id < 0 || m_CurrentVideo.syncState != IDVDStreamPlayer::SYNC_STARTING) &&
1925         (m_CurrentAudio.id < 0 || m_CurrentAudio.syncState != IDVDStreamPlayer::SYNC_STARTING))
1926       SetCaching(CACHESTATE_PLAY);
1927
1928     // handle exceptions
1929     if (m_CurrentAudio.id >= 0 && m_CurrentVideo.id >= 0)
1930     {
1931       if ((!m_VideoPlayerAudio->AcceptsData() || !m_VideoPlayerVideo->AcceptsData()) &&
1932           m_cachingTimer.IsTimePast())
1933       {
1934         SetCaching(CACHESTATE_DONE);
1935       }
1936     }
1937   }
1938
1939   if (m_caching == CACHESTATE_PLAY)
1940   {
1941     // if all enabled streams have started playing we are done
1942     if ((m_CurrentVideo.id < 0 || !m_VideoPlayerVideo->IsStalled()) &&
1943         (m_CurrentAudio.id < 0 || !m_VideoPlayerAudio->IsStalled()))
1944       SetCaching(CACHESTATE_DONE);
1945   }
1946
1947   if (m_caching == CACHESTATE_DONE)
1948   {
1949     if (m_playSpeed == DVD_PLAYSPEED_NORMAL && !tolerateStall)
1950     {
1951       // take action if audio or video stream is stalled
1952       if (((m_VideoPlayerAudio->IsStalled() && m_CurrentAudio.inited) ||
1953            (m_VideoPlayerVideo->IsStalled() && m_CurrentVideo.inited)) &&
1954           m_syncTimer.IsTimePast())
1955       {
1956         if (m_pInputStream->IsRealtime())
1957         {
1958           if ((m_CurrentAudio.id >= 0 && m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_INSYNC &&
1959                m_VideoPlayerAudio->IsStalled()) ||
1960               (m_CurrentVideo.id >= 0 && m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_INSYNC &&
1961                m_processInfo->GetLevelVQ() == 0))
1962           {
1963             CLog::Log(LOGDEBUG, "Stream stalled, start buffering. Audio: {} - Video: {}",
1964                       m_VideoPlayerAudio->GetLevel(), m_processInfo->GetLevelVQ());
1965
1966             if (m_VideoPlayerAudio->AcceptsData() && m_VideoPlayerVideo->AcceptsData())
1967               SetCaching(CACHESTATE_FULL);
1968             else
1969               FlushBuffers(DVD_NOPTS_VALUE, false, true);
1970           }
1971         }
1972         else
1973         {
1974           // start caching if audio and video have run dry
1975           if (m_VideoPlayerAudio->GetLevel() <= 50 &&
1976               m_processInfo->GetLevelVQ() <= 50)
1977           {
1978             SetCaching(CACHESTATE_FULL);
1979           }
1980           else if (m_CurrentAudio.id >= 0 && m_CurrentAudio.inited &&
1981                    m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_INSYNC &&
1982                    m_VideoPlayerAudio->GetLevel() == 0)
1983           {
1984             CLog::Log(LOGDEBUG,"CVideoPlayer::HandlePlaySpeed - audio stream stalled, triggering re-sync");
1985             FlushBuffers(DVD_NOPTS_VALUE, true, true);
1986             CDVDMsgPlayerSeek::CMode mode;
1987             mode.time = (int)GetUpdatedTime();
1988             mode.backward = false;
1989             mode.accurate = true;
1990             mode.sync = true;
1991             m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
1992           }
1993         }
1994       }
1995       // care for live streams
1996       else if (m_pInputStream->IsRealtime())
1997       {
1998         if (m_CurrentAudio.id >= 0)
1999         {
2000           double adjust = -1.0; // a unique value
2001           if (m_clock.GetSpeedAdjust() >= 0 && m_VideoPlayerAudio->GetLevel() < 5)
2002             adjust = -0.05;
2003
2004           if (m_clock.GetSpeedAdjust() < 0 && m_VideoPlayerAudio->GetLevel() > 10)
2005             adjust = 0.0;
2006
2007           if (adjust != -1.0)
2008           {
2009             m_clock.SetSpeedAdjust(adjust);
2010           }
2011         }
2012       }
2013     }
2014   }
2015
2016   // sync streams to clock
2017   if ((m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_WAITSYNC) ||
2018       (m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_WAITSYNC))
2019   {
2020     unsigned int threshold = 20;
2021     if (m_pInputStream->IsRealtime())
2022       threshold = 40;
2023
2024     bool video = m_CurrentVideo.id < 0 || (m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_WAITSYNC) ||
2025                  (m_CurrentVideo.packets == 0 && m_CurrentAudio.packets > threshold) ||
2026                  (!m_VideoPlayerAudio->AcceptsData() && m_processInfo->GetLevelVQ() < 10);
2027     bool audio = m_CurrentAudio.id < 0 || (m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_WAITSYNC) ||
2028                  (m_CurrentAudio.packets == 0 && m_CurrentVideo.packets > threshold) ||
2029                  (!m_VideoPlayerVideo->AcceptsData() && m_VideoPlayerAudio->GetLevel() < 10);
2030
2031     if (m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_WAITSYNC &&
2032         (m_CurrentAudio.avsync == CCurrentStream::AV_SYNC_CONT ||
2033          m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_INSYNC))
2034     {
2035       m_CurrentAudio.syncState = IDVDStreamPlayer::SYNC_INSYNC;
2036       m_CurrentAudio.avsync = CCurrentStream::AV_SYNC_NONE;
2037       m_VideoPlayerAudio->SendMessage(
2038           std::make_shared<CDVDMsgDouble>(CDVDMsg::GENERAL_RESYNC, m_clock.GetClock()), 1);
2039     }
2040     else if (m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_WAITSYNC &&
2041              (m_CurrentVideo.avsync == CCurrentStream::AV_SYNC_CONT ||
2042              m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_INSYNC))
2043     {
2044       m_CurrentVideo.syncState = IDVDStreamPlayer::SYNC_INSYNC;
2045       m_CurrentVideo.avsync = CCurrentStream::AV_SYNC_NONE;
2046       m_VideoPlayerVideo->SendMessage(
2047           std::make_shared<CDVDMsgDouble>(CDVDMsg::GENERAL_RESYNC, m_clock.GetClock()), 1);
2048     }
2049     else if (video && audio)
2050     {
2051       double clock = 0;
2052       if (m_CurrentAudio.syncState == IDVDStreamPlayer::SYNC_WAITSYNC)
2053         CLog::Log(LOGDEBUG, "VideoPlayer::Sync - Audio - pts: {:f}, cache: {:f}, totalcache: {:f}",
2054                   m_CurrentAudio.starttime, m_CurrentAudio.cachetime, m_CurrentAudio.cachetotal);
2055       if (m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_WAITSYNC)
2056         CLog::Log(LOGDEBUG, "VideoPlayer::Sync - Video - pts: {:f}, cache: {:f}, totalcache: {:f}",
2057                   m_CurrentVideo.starttime, m_CurrentVideo.cachetime, m_CurrentVideo.cachetotal);
2058
2059       if (m_CurrentVideo.starttime != DVD_NOPTS_VALUE && m_CurrentVideo.packets > 0 &&
2060           m_playSpeed == DVD_PLAYSPEED_PAUSE)
2061       {
2062         clock = m_CurrentVideo.starttime;
2063       }
2064       else if (m_CurrentAudio.starttime != DVD_NOPTS_VALUE && m_CurrentAudio.packets > 0)
2065       {
2066         if (m_pInputStream->IsRealtime())
2067           clock = m_CurrentAudio.starttime - m_CurrentAudio.cachetotal - DVD_MSEC_TO_TIME(400);
2068         else
2069           clock = m_CurrentAudio.starttime - m_CurrentAudio.cachetime;
2070
2071         if (m_CurrentVideo.starttime != DVD_NOPTS_VALUE && (m_CurrentVideo.packets > 0))
2072         {
2073           if (m_CurrentVideo.starttime - m_CurrentVideo.cachetotal < clock)
2074           {
2075             clock = m_CurrentVideo.starttime - m_CurrentVideo.cachetotal;
2076           }
2077           else if (m_CurrentVideo.starttime > m_CurrentAudio.starttime &&
2078                    !m_pInputStream->IsRealtime())
2079           {
2080             int audioLevel = m_VideoPlayerAudio->GetLevel();
2081             //@todo hardcoded 8 seconds in message queue
2082             double maxAudioTime = clock + DVD_MSEC_TO_TIME(80 * audioLevel);
2083             if ((m_CurrentVideo.starttime - m_CurrentVideo.cachetotal) > maxAudioTime)
2084               clock = maxAudioTime;
2085             else
2086               clock = m_CurrentVideo.starttime - m_CurrentVideo.cachetotal;
2087           }
2088         }
2089       }
2090       else if (m_CurrentVideo.starttime != DVD_NOPTS_VALUE && m_CurrentVideo.packets > 0)
2091       {
2092         clock = m_CurrentVideo.starttime - m_CurrentVideo.cachetotal;
2093       }
2094
2095       m_clock.Discontinuity(clock);
2096       m_CurrentAudio.syncState = IDVDStreamPlayer::SYNC_INSYNC;
2097       m_CurrentAudio.avsync = CCurrentStream::AV_SYNC_NONE;
2098       m_CurrentVideo.syncState = IDVDStreamPlayer::SYNC_INSYNC;
2099       m_CurrentVideo.avsync = CCurrentStream::AV_SYNC_NONE;
2100       m_VideoPlayerAudio->SendMessage(
2101           std::make_shared<CDVDMsgDouble>(CDVDMsg::GENERAL_RESYNC, clock), 1);
2102       m_VideoPlayerVideo->SendMessage(
2103           std::make_shared<CDVDMsgDouble>(CDVDMsg::GENERAL_RESYNC, clock), 1);
2104       SetCaching(CACHESTATE_DONE);
2105       UpdatePlayState(0);
2106
2107       m_syncTimer.Set(3000ms);
2108
2109       if (!m_State.streamsReady)
2110       {
2111         if (m_playerOptions.fullscreen)
2112         {
2113           CServiceBroker::GetAppMessenger()->PostMsg(TMSG_SWITCHTOFULLSCREEN);
2114         }
2115
2116         IPlayerCallback *cb = &m_callback;
2117         CFileItem fileItem = m_item;
2118         m_outboundEvents->Submit([=]() {
2119           cb->OnAVStarted(fileItem);
2120         });
2121         m_State.streamsReady = true;
2122       }
2123     }
2124     else
2125     {
2126       // exceptions for which stream players won't start properly
2127       // 1. videoplayer has not detected a keyframe within length of demux buffers
2128       if (m_CurrentAudio.id >= 0 && m_CurrentVideo.id >= 0 &&
2129           !m_VideoPlayerAudio->AcceptsData() &&
2130           m_CurrentVideo.syncState == IDVDStreamPlayer::SYNC_STARTING &&
2131           m_VideoPlayerVideo->IsStalled() &&
2132           m_CurrentVideo.packets > 10)
2133       {
2134         m_VideoPlayerAudio->AcceptsData();
2135         CLog::Log(LOGWARNING, "VideoPlayer::Sync - stream player video does not start, flushing buffers");
2136         FlushBuffers(DVD_NOPTS_VALUE, true, true);
2137       }
2138     }
2139   }
2140
2141   // handle ff/rw
2142   if (m_playSpeed != DVD_PLAYSPEED_NORMAL && m_playSpeed != DVD_PLAYSPEED_PAUSE)
2143   {
2144     if (isInMenu)
2145     {
2146       // this can't be done in menu
2147       SetPlaySpeed(DVD_PLAYSPEED_NORMAL);
2148
2149     }
2150     else
2151     {
2152       bool check = true;
2153
2154       // only check if we have video
2155       if (m_CurrentVideo.id < 0 || m_CurrentVideo.syncState != IDVDStreamPlayer::SYNC_INSYNC)
2156         check = false;
2157       // video message queue either initiated or already seen eof
2158       else if (m_CurrentVideo.inited == false && m_playSpeed >= 0)
2159         check = false;
2160       // don't check if time has not advanced since last check
2161       else if (m_SpeedState.lasttime == GetTime())
2162         check = false;
2163       // skip if frame at screen has no valid timestamp
2164       else if (m_VideoPlayerVideo->GetCurrentPts() == DVD_NOPTS_VALUE)
2165         check = false;
2166       // skip if frame on screen has not changed
2167       else if (m_SpeedState.lastpts == m_VideoPlayerVideo->GetCurrentPts() &&
2168                (m_SpeedState.lastpts > m_State.dts || m_playSpeed > 0))
2169         check = false;
2170
2171       if (check)
2172       {
2173         m_SpeedState.lastpts  = m_VideoPlayerVideo->GetCurrentPts();
2174         m_SpeedState.lasttime = GetTime();
2175         m_SpeedState.lastabstime = m_clock.GetAbsoluteClock();
2176
2177         double error;
2178         error  = m_clock.GetClock() - m_SpeedState.lastpts;
2179         error *= m_playSpeed / abs(m_playSpeed);
2180
2181         // allow a bigger error when going ff, the faster we go
2182         // the the bigger is the error we allow
2183         if (m_playSpeed > DVD_PLAYSPEED_NORMAL)
2184         {
2185           double errorwin = static_cast<double>(m_playSpeed) / DVD_PLAYSPEED_NORMAL;
2186           if (errorwin > 8.0)
2187             errorwin = 8.0;
2188           error /= errorwin;
2189         }
2190
2191         if (error > DVD_MSEC_TO_TIME(1000))
2192         {
2193           error  = (m_clock.GetClock() - m_SpeedState.lastseekpts) / 1000;
2194
2195           if (std::abs(error) > 1000 || (m_VideoPlayerVideo->IsRewindStalled() && std::abs(error) > 100))
2196           {
2197             CLog::Log(LOGDEBUG, "CVideoPlayer::Process - Seeking to catch up, error was: {:f}",
2198                       error);
2199             m_SpeedState.lastseekpts = m_clock.GetClock();
2200             int direction = (m_playSpeed > 0) ? 1 : -1;
2201             double iTime = (m_clock.GetClock() + m_State.time_offset + 1000000.0 * direction) / 1000;
2202             CDVDMsgPlayerSeek::CMode mode;
2203             mode.time = iTime;
2204             mode.backward = (m_playSpeed < 0);
2205             mode.accurate = false;
2206             mode.restore = false;
2207             mode.trickplay = true;
2208             mode.sync = false;
2209             m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2210           }
2211         }
2212       }
2213     }
2214   }
2215
2216   // reset tempo
2217   if (!m_State.cantempo)
2218   {
2219     float currentTempo = m_processInfo->GetNewTempo();
2220     if (currentTempo != 1.0f)
2221     {
2222       SetTempo(1.0f);
2223     }
2224   }
2225 }
2226
2227 bool CVideoPlayer::CheckPlayerInit(CCurrentStream& current)
2228 {
2229   if (current.inited)
2230     return false;
2231
2232   if (current.startpts != DVD_NOPTS_VALUE)
2233   {
2234     if(current.dts == DVD_NOPTS_VALUE)
2235     {
2236       CLog::Log(LOGDEBUG, "{} - dropping packet type:{} dts:{:f} to get to start point at {:f}",
2237                 __FUNCTION__, current.player, current.dts, current.startpts);
2238       return true;
2239     }
2240
2241     if ((current.startpts - current.dts) > DVD_SEC_TO_TIME(20))
2242     {
2243       CLog::Log(LOGDEBUG, "{} - too far to decode before finishing seek", __FUNCTION__);
2244       if(m_CurrentAudio.startpts != DVD_NOPTS_VALUE)
2245         m_CurrentAudio.startpts = current.dts;
2246       if(m_CurrentVideo.startpts != DVD_NOPTS_VALUE)
2247         m_CurrentVideo.startpts = current.dts;
2248       if(m_CurrentSubtitle.startpts != DVD_NOPTS_VALUE)
2249         m_CurrentSubtitle.startpts = current.dts;
2250       if(m_CurrentTeletext.startpts != DVD_NOPTS_VALUE)
2251         m_CurrentTeletext.startpts = current.dts;
2252       if(m_CurrentRadioRDS.startpts != DVD_NOPTS_VALUE)
2253         m_CurrentRadioRDS.startpts = current.dts;
2254       if (m_CurrentAudioID3.startpts != DVD_NOPTS_VALUE)
2255         m_CurrentAudioID3.startpts = current.dts;
2256     }
2257
2258     if(current.dts < current.startpts)
2259     {
2260       CLog::Log(LOGDEBUG, "{} - dropping packet type:{} dts:{:f} to get to start point at {:f}",
2261                 __FUNCTION__, current.player, current.dts, current.startpts);
2262       return true;
2263     }
2264   }
2265
2266   if (current.dts != DVD_NOPTS_VALUE)
2267   {
2268     current.inited = true;
2269     current.startpts = current.dts;
2270   }
2271   return false;
2272 }
2273
2274 void CVideoPlayer::UpdateCorrection(DemuxPacket* pkt, double correction)
2275 {
2276   pkt->m_ptsOffsetCorrection = correction;
2277
2278   if(pkt->dts != DVD_NOPTS_VALUE)
2279     pkt->dts -= correction;
2280   if(pkt->pts != DVD_NOPTS_VALUE)
2281     pkt->pts -= correction;
2282 }
2283
2284 void CVideoPlayer::UpdateTimestamps(CCurrentStream& current, DemuxPacket* pPacket)
2285 {
2286   double dts = current.dts;
2287   /* update stored values */
2288   if(pPacket->dts != DVD_NOPTS_VALUE)
2289     dts = pPacket->dts;
2290   else if(pPacket->pts != DVD_NOPTS_VALUE)
2291     dts = pPacket->pts;
2292
2293   /* calculate some average duration */
2294   if(pPacket->duration != DVD_NOPTS_VALUE)
2295     current.dur = pPacket->duration;
2296   else if(dts != DVD_NOPTS_VALUE && current.dts != DVD_NOPTS_VALUE)
2297     current.dur = 0.1 * (current.dur * 9 + (dts - current.dts));
2298
2299   current.dts = dts;
2300
2301   current.dispTime = pPacket->dispTime;
2302 }
2303
2304 static void UpdateLimits(double& minimum, double& maximum, double dts)
2305 {
2306   if(dts == DVD_NOPTS_VALUE)
2307     return;
2308   if(minimum == DVD_NOPTS_VALUE || minimum > dts) minimum = dts;
2309   if(maximum == DVD_NOPTS_VALUE || maximum < dts) maximum = dts;
2310 }
2311
2312 bool CVideoPlayer::CheckContinuity(CCurrentStream& current, DemuxPacket* pPacket)
2313 {
2314   if (m_playSpeed < DVD_PLAYSPEED_PAUSE)
2315     return false;
2316
2317   if( pPacket->dts == DVD_NOPTS_VALUE || current.dts == DVD_NOPTS_VALUE)
2318     return false;
2319
2320   double mindts = DVD_NOPTS_VALUE, maxdts = DVD_NOPTS_VALUE;
2321   UpdateLimits(mindts, maxdts, m_CurrentAudio.dts);
2322   UpdateLimits(mindts, maxdts, m_CurrentVideo.dts);
2323   UpdateLimits(mindts, maxdts, m_CurrentAudio.dts_end());
2324   UpdateLimits(mindts, maxdts, m_CurrentVideo.dts_end());
2325
2326   /* if we don't have max and min, we can't do anything more */
2327   if( mindts == DVD_NOPTS_VALUE || maxdts == DVD_NOPTS_VALUE )
2328     return false;
2329
2330   double correction = 0.0;
2331   if( pPacket->dts > maxdts + DVD_MSEC_TO_TIME(1000))
2332   {
2333     CLog::Log(LOGDEBUG,
2334               "CVideoPlayer::CheckContinuity - resync forward :{}, prev:{:f}, curr:{:f}, diff:{:f}",
2335               current.type, current.dts, pPacket->dts, pPacket->dts - maxdts);
2336     correction = pPacket->dts - maxdts;
2337   }
2338
2339   /* if it's large scale jump, correct for it after having confirmed the jump */
2340   if(pPacket->dts + DVD_MSEC_TO_TIME(500) < current.dts_end())
2341   {
2342     CLog::Log(
2343         LOGDEBUG,
2344         "CVideoPlayer::CheckContinuity - resync backward :{}, prev:{:f}, curr:{:f}, diff:{:f}",
2345         current.type, current.dts, pPacket->dts, pPacket->dts - current.dts);
2346     correction = pPacket->dts - current.dts_end();
2347   }
2348   else if(pPacket->dts < current.dts)
2349   {
2350     CLog::Log(LOGDEBUG,
2351               "CVideoPlayer::CheckContinuity - wrapback :{}, prev:{:f}, curr:{:f}, diff:{:f}",
2352               current.type, current.dts, pPacket->dts, pPacket->dts - current.dts);
2353   }
2354
2355   double lastdts = pPacket->dts;
2356   if(correction != 0.0)
2357   {
2358     // we want the dts values of two streams to close, or for one to be invalid (e.g. from a missing audio stream)
2359     double this_dts = pPacket->dts;
2360     double that_dts = current.type == STREAM_AUDIO ? m_CurrentVideo.lastdts : m_CurrentAudio.lastdts;
2361
2362     if (m_CurrentAudio.id == -1 || m_CurrentVideo.id == -1 ||
2363        current.lastdts == DVD_NOPTS_VALUE ||
2364        fabs(this_dts - that_dts) < DVD_MSEC_TO_TIME(1000))
2365     {
2366       m_offset_pts += correction;
2367       UpdateCorrection(pPacket, correction);
2368       lastdts = pPacket->dts;
2369       CLog::Log(LOGDEBUG, "CVideoPlayer::CheckContinuity - update correction: {:f}", correction);
2370       if (current.avsync == CCurrentStream::AV_SYNC_CHECK)
2371         current.avsync = CCurrentStream::AV_SYNC_CONT;
2372     }
2373     else
2374     {
2375       // not sure yet - flags the packets as unknown until we get confirmation on another audio/video packet
2376       pPacket->dts = DVD_NOPTS_VALUE;
2377       pPacket->pts = DVD_NOPTS_VALUE;
2378     }
2379   }
2380   else
2381   {
2382     if (current.avsync == CCurrentStream::AV_SYNC_CHECK)
2383       current.avsync = CCurrentStream::AV_SYNC_CONT;
2384   }
2385   current.lastdts = lastdts;
2386   return true;
2387 }
2388
2389 bool CVideoPlayer::CheckSceneSkip(const CCurrentStream& current)
2390 {
2391   if (!m_Edl.HasEdits())
2392     return false;
2393
2394   if(current.dts == DVD_NOPTS_VALUE)
2395     return false;
2396
2397   if(current.inited == false)
2398     return false;
2399
2400   const auto hasEdit =
2401       m_Edl.InEdit(std::chrono::milliseconds(std::lround(current.dts + m_offset_pts)));
2402   return hasEdit && hasEdit.value()->action == EDL::Action::CUT;
2403 }
2404
2405 void CVideoPlayer::CheckAutoSceneSkip()
2406 {
2407   if (!m_Edl.HasEdits())
2408     return;
2409
2410   // Check that there is an audio and video stream.
2411   if((m_CurrentAudio.id < 0 || m_CurrentAudio.syncState != IDVDStreamPlayer::SYNC_INSYNC) ||
2412      (m_CurrentVideo.id < 0 || m_CurrentVideo.syncState != IDVDStreamPlayer::SYNC_INSYNC))
2413     return;
2414
2415   // If there is a startpts defined for either the audio or video stream then VideoPlayer is still
2416   // still decoding frames to get to the previously requested seek point.
2417   if (m_CurrentAudio.inited == false ||
2418       m_CurrentVideo.inited == false)
2419     return;
2420
2421   const std::chrono::milliseconds clock{GetTime()};
2422
2423   const std::chrono::milliseconds correctClock = m_Edl.GetTimeAfterRestoringCuts(clock);
2424   const auto hasEdit = m_Edl.InEdit(correctClock);
2425   if (!hasEdit)
2426   {
2427     // @note: Users are allowed to jump back into EDL commercial breaks
2428     // do not reset the last edit time if the last surpassed edit is a commercial break
2429     if (m_Edl.GetLastEditActionType() != EDL::Action::COMM_BREAK)
2430     {
2431       m_Edl.ResetLastEditTime();
2432     }
2433     return;
2434   }
2435
2436   const auto& edit = hasEdit.value();
2437   if (edit->action == EDL::Action::CUT)
2438   {
2439     if ((m_playSpeed > 0 && correctClock < (edit->start + 1s)) ||
2440         (m_playSpeed < 0 && correctClock < (edit->end - 1s)))
2441     {
2442       CLog::Log(LOGDEBUG, "{} - Clock in EDL cut [{} - {}]: {}. Automatically skipping over.",
2443                 __FUNCTION__, CEdl::MillisecondsToTimeString(edit->start),
2444                 CEdl::MillisecondsToTimeString(edit->end), CEdl::MillisecondsToTimeString(clock));
2445
2446       // Seeking either goes to the start or the end of the cut depending on the play direction.
2447       std::chrono::milliseconds seek = m_playSpeed >= 0 ? edit->end : edit->start;
2448       if (m_Edl.GetLastEditTime() != seek)
2449       {
2450         CDVDMsgPlayerSeek::CMode mode;
2451         mode.time = seek.count();
2452         mode.backward = true;
2453         mode.accurate = true;
2454         mode.restore = false;
2455         mode.trickplay = false;
2456         mode.sync = true;
2457         m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2458
2459         m_Edl.SetLastEditTime(seek);
2460         m_Edl.SetLastEditActionType(edit->action);
2461       }
2462     }
2463   }
2464   else if (edit->action == EDL::Action::COMM_BREAK)
2465   {
2466     // marker for commbreak may be inaccurate. allow user to skip into break from the back
2467     if (m_playSpeed >= 0 && m_Edl.GetLastEditTime() != edit->start && clock < edit->end - 1s)
2468     {
2469       const std::shared_ptr<CAdvancedSettings> advancedSettings =
2470           CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
2471       if (advancedSettings && advancedSettings->m_EdlDisplayCommbreakNotifications)
2472       {
2473         const std::string timeString = StringUtils::SecondsToTimeString(
2474             std::chrono::duration_cast<std::chrono::seconds>(edit->end - edit->start).count(),
2475             TIME_FORMAT_MM_SS);
2476         CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(25011), timeString);
2477       }
2478
2479       m_Edl.SetLastEditTime(edit->start);
2480       m_Edl.SetLastEditActionType(edit->action);
2481
2482       if (m_SkipCommercials)
2483       {
2484         CLog::Log(LOGDEBUG,
2485                   "{} - Clock in commercial break [{} - {}]: {}. Automatically skipping to end of "
2486                   "commercial break",
2487                   __FUNCTION__, CEdl::MillisecondsToTimeString(edit->start),
2488                   CEdl::MillisecondsToTimeString(edit->end), CEdl::MillisecondsToTimeString(clock));
2489
2490         CDVDMsgPlayerSeek::CMode mode;
2491         mode.time = edit->end.count();
2492         mode.backward = true;
2493         mode.accurate = true;
2494         mode.restore = false;
2495         mode.trickplay = false;
2496         mode.sync = true;
2497         m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2498       }
2499     }
2500   }
2501 }
2502
2503
2504 void CVideoPlayer::SynchronizeDemuxer()
2505 {
2506   if(IsCurrentThread())
2507     return;
2508   if(!m_messenger.IsInited())
2509     return;
2510
2511   auto message = std::make_shared<CDVDMsgGeneralSynchronize>(500ms, SYNCSOURCE_PLAYER);
2512   m_messenger.Put(message);
2513   message->Wait(m_bStop, 0);
2514 }
2515
2516 IDVDStreamPlayer* CVideoPlayer::GetStreamPlayer(unsigned int target)
2517 {
2518   if(target == VideoPlayer_AUDIO)
2519     return m_VideoPlayerAudio;
2520   if(target == VideoPlayer_VIDEO)
2521     return m_VideoPlayerVideo;
2522   if(target == VideoPlayer_SUBTITLE)
2523     return m_VideoPlayerSubtitle;
2524   if(target == VideoPlayer_TELETEXT)
2525     return m_VideoPlayerTeletext;
2526   if(target == VideoPlayer_RDS)
2527     return m_VideoPlayerRadioRDS;
2528   if (target == VideoPlayer_ID3)
2529     return m_VideoPlayerAudioID3.get();
2530   return NULL;
2531 }
2532
2533 void CVideoPlayer::SendPlayerMessage(std::shared_ptr<CDVDMsg> pMsg, unsigned int target)
2534 {
2535   IDVDStreamPlayer* player = GetStreamPlayer(target);
2536   if(player)
2537     player->SendMessage(std::move(pMsg), 0);
2538 }
2539
2540 void CVideoPlayer::OnExit()
2541 {
2542   CLog::Log(LOGINFO, "CVideoPlayer::OnExit()");
2543
2544   // set event to inform openfile something went wrong in case openfile is still waiting for this event
2545   SetCaching(CACHESTATE_DONE);
2546
2547   // close each stream
2548   if (!m_bAbortRequest)
2549     CLog::Log(LOGINFO, "VideoPlayer: eof, waiting for queues to empty");
2550
2551   CFileItem fileItem(m_item);
2552   UpdateFileItemStreamDetails(fileItem);
2553
2554   CloseStream(m_CurrentAudio, !m_bAbortRequest);
2555   CloseStream(m_CurrentVideo, !m_bAbortRequest);
2556   CloseStream(m_CurrentTeletext,!m_bAbortRequest);
2557   CloseStream(m_CurrentRadioRDS, !m_bAbortRequest);
2558   CloseStream(m_CurrentAudioID3, !m_bAbortRequest);
2559   // the generalization principle was abused for subtitle player. actually it is not a stream player like
2560   // video and audio. subtitle player does not run on its own thread, hence waitForBuffers makes
2561   // no sense here. waitForBuffers is abused to clear overlay container (false clears container)
2562   // subtitles are added from video player. after video player has finished, overlays have to be cleared.
2563   CloseStream(m_CurrentSubtitle, false);  // clear overlay container
2564
2565   CServiceBroker::GetWinSystem()->UnregisterRenderLoop(this);
2566
2567   IPlayerCallback *cb = &m_callback;
2568   CVideoSettings vs = m_processInfo->GetVideoSettings();
2569   m_outboundEvents->Submit([=]() {
2570     cb->StoreVideoSettings(fileItem, vs);
2571   });
2572
2573   CBookmark bookmark;
2574   bookmark.totalTimeInSeconds = 0;
2575   bookmark.timeInSeconds = 0;
2576   if (m_State.startTime == 0)
2577   {
2578     bookmark.totalTimeInSeconds = m_State.timeMax / 1000;
2579     bookmark.timeInSeconds = m_State.time / 1000;
2580   }
2581   bookmark.player = m_name;
2582   bookmark.playerState = GetPlayerState();
2583   m_outboundEvents->Submit([=]() {
2584     cb->OnPlayerCloseFile(fileItem, bookmark);
2585   });
2586
2587   // destroy objects
2588   m_renderManager.Flush(false, false);
2589   m_pDemuxer.reset();
2590   m_pSubtitleDemuxer.reset();
2591   m_subtitleDemuxerMap.clear();
2592   m_pCCDemuxer.reset();
2593   if (m_pInputStream.use_count() > 1)
2594     throw std::runtime_error("m_pInputStream reference count is greater than 1");
2595   m_pInputStream.reset();
2596
2597   // clean up all selection streams
2598   m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_NONE);
2599
2600   m_messenger.End();
2601
2602   CFFmpegLog::ClearLogLevel();
2603   m_bStop = true;
2604
2605   bool error = m_error;
2606   bool close = m_bCloseRequest;
2607   m_outboundEvents->Submit([=]() {
2608     if (close)
2609       cb->OnPlayBackStopped();
2610     else if (error)
2611       cb->OnPlayBackError();
2612     else
2613       cb->OnPlayBackEnded();
2614   });
2615 }
2616
2617 void CVideoPlayer::HandleMessages()
2618 {
2619   std::shared_ptr<CDVDMsg> pMsg = nullptr;
2620
2621   while (m_messenger.Get(pMsg, 0ms) == MSGQ_OK)
2622   {
2623     if (pMsg->IsType(CDVDMsg::PLAYER_OPENFILE) &&
2624         m_messenger.GetPacketCount(CDVDMsg::PLAYER_OPENFILE) == 0)
2625     {
2626       CDVDMsgOpenFile& msg(*std::static_pointer_cast<CDVDMsgOpenFile>(pMsg));
2627
2628       IPlayerCallback *cb = &m_callback;
2629       CFileItem fileItem(m_item);
2630       UpdateFileItemStreamDetails(fileItem);
2631       CVideoSettings vs = m_processInfo->GetVideoSettings();
2632       m_outboundEvents->Submit([=]() {
2633         cb->StoreVideoSettings(fileItem, vs);
2634       });
2635
2636       CBookmark bookmark;
2637       bookmark.totalTimeInSeconds = 0;
2638       bookmark.timeInSeconds = 0;
2639       if (m_State.startTime == 0)
2640       {
2641         bookmark.totalTimeInSeconds = m_State.timeMax / 1000;
2642         bookmark.timeInSeconds = m_State.time / 1000;
2643       }
2644       bookmark.player = m_name;
2645       bookmark.playerState = GetPlayerState();
2646       m_outboundEvents->Submit([=]() {
2647         cb->OnPlayerCloseFile(fileItem, bookmark);
2648       });
2649
2650       m_item = msg.GetItem();
2651       m_playerOptions = msg.GetOptions();
2652
2653       m_processInfo->SetPlayTimes(0,0,0,0);
2654
2655       m_outboundEvents->Submit([this]() {
2656         m_callback.OnPlayBackStarted(m_item);
2657       });
2658
2659       FlushBuffers(DVD_NOPTS_VALUE, true, true);
2660       m_renderManager.Flush(false, false);
2661       m_pDemuxer.reset();
2662       m_pSubtitleDemuxer.reset();
2663       m_subtitleDemuxerMap.clear();
2664       m_pCCDemuxer.reset();
2665       if (m_pInputStream.use_count() > 1)
2666         throw std::runtime_error("m_pInputStream reference count is greater than 1");
2667       m_pInputStream.reset();
2668
2669       m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_NONE);
2670
2671       Prepare();
2672     }
2673     else if (pMsg->IsType(CDVDMsg::PLAYER_SEEK) &&
2674         m_messenger.GetPacketCount(CDVDMsg::PLAYER_SEEK) == 0 &&
2675         m_messenger.GetPacketCount(CDVDMsg::PLAYER_SEEK_CHAPTER) == 0)
2676     {
2677       CDVDMsgPlayerSeek& msg(*std::static_pointer_cast<CDVDMsgPlayerSeek>(pMsg));
2678
2679       if (!m_State.canseek)
2680       {
2681         m_processInfo->SetStateSeeking(false);
2682         continue;
2683       }
2684
2685       // skip seeks if player has not finished the last seek
2686       if (m_CurrentVideo.id >= 0 &&
2687           m_CurrentVideo.syncState != IDVDStreamPlayer::SYNC_INSYNC)
2688       {
2689         double now = m_clock.GetAbsoluteClock();
2690         if (m_playSpeed == DVD_PLAYSPEED_NORMAL &&
2691             (now - m_State.lastSeek)/1000 < 2000 &&
2692             !msg.GetAccurate())
2693         {
2694           m_processInfo->SetStateSeeking(false);
2695           continue;
2696         }
2697       }
2698
2699       if (!msg.GetTrickPlay())
2700       {
2701         m_processInfo->SeekFinished(0);
2702         SetCaching(CACHESTATE_FLUSH);
2703       }
2704
2705       double start = DVD_NOPTS_VALUE;
2706
2707       double time = msg.GetTime();
2708       if (msg.GetRelative())
2709         time = (m_clock.GetClock() + m_State.time_offset) / 1000l + time;
2710
2711       time = msg.GetRestore()
2712                  ? m_Edl.GetTimeAfterRestoringCuts(std::chrono::milliseconds(std::lround(time)))
2713                        .count()
2714                  : time;
2715
2716       // if input stream doesn't support ISeekTime, convert back to pts
2717       //! @todo
2718       //! After demuxer we add an offset to input pts so that displayed time and clock are
2719       //! increasing steadily. For seeking we need to determine the boundaries and offset
2720       //! of the desired segment. With the current approach calculated time may point
2721       //! to nirvana
2722       if (m_pInputStream->GetIPosTime() == nullptr)
2723         time -= m_State.time_offset/1000l;
2724
2725       CLog::Log(LOGDEBUG, "demuxer seek to: {:f}", time);
2726       if (m_pDemuxer && m_pDemuxer->SeekTime(time, msg.GetBackward(), &start))
2727       {
2728         CLog::Log(LOGDEBUG, "demuxer seek to: {:f}, success", time);
2729         if(m_pSubtitleDemuxer)
2730         {
2731           if(!m_pSubtitleDemuxer->SeekTime(time, msg.GetBackward()))
2732             CLog::Log(LOGDEBUG, "failed to seek subtitle demuxer: {:f}, success", time);
2733         }
2734         // dts after successful seek
2735         if (start == DVD_NOPTS_VALUE)
2736           start = DVD_MSEC_TO_TIME(time) - m_State.time_offset;
2737
2738         m_State.dts = start;
2739         m_State.lastSeek = m_clock.GetAbsoluteClock();
2740
2741         FlushBuffers(start, msg.GetAccurate(), msg.GetSync());
2742       }
2743       else if (m_pDemuxer)
2744       {
2745         CLog::Log(LOGDEBUG, "VideoPlayer: seek failed or hit end of stream");
2746         // dts after successful seek
2747         if (start == DVD_NOPTS_VALUE)
2748           start = DVD_MSEC_TO_TIME(time) - m_State.time_offset;
2749
2750         m_State.dts = start;
2751
2752         FlushBuffers(start, false, true);
2753         if (m_playSpeed != DVD_PLAYSPEED_PAUSE)
2754         {
2755           SetPlaySpeed(DVD_PLAYSPEED_NORMAL);
2756         }
2757       }
2758
2759       // set flag to indicate we have finished a seeking request
2760       if(!msg.GetTrickPlay())
2761       {
2762         m_processInfo->SeekFinished(0);
2763       }
2764
2765       // dvd's will issue a HOP_CHANNEL that we need to skip
2766       if(m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
2767         m_dvd.state = DVDSTATE_SEEK;
2768
2769       m_processInfo->SetStateSeeking(false);
2770     }
2771     else if (pMsg->IsType(CDVDMsg::PLAYER_SEEK_CHAPTER) &&
2772              m_messenger.GetPacketCount(CDVDMsg::PLAYER_SEEK) == 0 &&
2773              m_messenger.GetPacketCount(CDVDMsg::PLAYER_SEEK_CHAPTER) == 0)
2774     {
2775       m_processInfo->SeekFinished(0);
2776       SetCaching(CACHESTATE_FLUSH);
2777
2778       CDVDMsgPlayerSeekChapter& msg(*std::static_pointer_cast<CDVDMsgPlayerSeekChapter>(pMsg));
2779       double start = DVD_NOPTS_VALUE;
2780       int offset = 0;
2781
2782       // This should always be the case.
2783       if(m_pDemuxer && m_pDemuxer->SeekChapter(msg.GetChapter(), &start))
2784       {
2785         FlushBuffers(start, true, true);
2786         int64_t beforeSeek = GetTime();
2787         offset = DVD_TIME_TO_MSEC(start) - static_cast<int>(beforeSeek);
2788         m_callback.OnPlayBackSeekChapter(msg.GetChapter());
2789       }
2790       else if (m_pInputStream)
2791       {
2792         CDVDInputStream::IChapter* pChapter = m_pInputStream->GetIChapter();
2793         if (pChapter && pChapter->SeekChapter(msg.GetChapter()))
2794         {
2795           FlushBuffers(start, true, true);
2796           int64_t beforeSeek = GetTime();
2797           offset = DVD_TIME_TO_MSEC(start) - static_cast<int>(beforeSeek);
2798           m_callback.OnPlayBackSeekChapter(msg.GetChapter());
2799         }
2800       }
2801       m_processInfo->SeekFinished(offset);
2802     }
2803     else if (pMsg->IsType(CDVDMsg::DEMUXER_RESET))
2804     {
2805       m_CurrentAudio.stream = NULL;
2806       m_CurrentVideo.stream = NULL;
2807       m_CurrentSubtitle.stream = NULL;
2808
2809       // we need to reset the demuxer, probably because the streams have changed
2810       if(m_pDemuxer)
2811         m_pDemuxer->Reset();
2812       if(m_pSubtitleDemuxer)
2813         m_pSubtitleDemuxer->Reset();
2814     }
2815     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_AUDIOSTREAM))
2816     {
2817       auto pMsg2 = std::static_pointer_cast<CDVDMsgPlayerSetAudioStream>(pMsg);
2818
2819       SelectionStream& st = m_SelectionStreams.Get(STREAM_AUDIO, pMsg2->GetStreamId());
2820       if(st.source != STREAM_SOURCE_NONE)
2821       {
2822         if(st.source == STREAM_SOURCE_NAV && m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
2823         {
2824           std::shared_ptr<CDVDInputStreamNavigator> pStream = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
2825           if(pStream->SetActiveAudioStream(st.id))
2826           {
2827             m_dvd.iSelectedAudioStream = -1;
2828             CloseStream(m_CurrentAudio, false);
2829             CDVDMsgPlayerSeek::CMode mode;
2830             mode.time = (int)GetUpdatedTime();
2831             mode.backward = true;
2832             mode.accurate = true;
2833             mode.trickplay = true;
2834             mode.sync = true;
2835             m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2836           }
2837         }
2838         else
2839         {
2840           CloseStream(m_CurrentAudio, false);
2841           OpenStream(m_CurrentAudio, st.demuxerId, st.id, st.source);
2842           AdaptForcedSubtitles();
2843
2844           CDVDMsgPlayerSeek::CMode mode;
2845           mode.time = (int)GetUpdatedTime();
2846           mode.backward = true;
2847           mode.accurate = true;
2848           mode.trickplay = true;
2849           mode.sync = true;
2850           m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2851         }
2852       }
2853     }
2854     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_VIDEOSTREAM))
2855     {
2856       auto pMsg2 = std::static_pointer_cast<CDVDMsgPlayerSetVideoStream>(pMsg);
2857
2858       SelectionStream& st = m_SelectionStreams.Get(STREAM_VIDEO, pMsg2->GetStreamId());
2859       if (st.source != STREAM_SOURCE_NONE)
2860       {
2861         if (st.source == STREAM_SOURCE_NAV && m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
2862         {
2863           std::shared_ptr<CDVDInputStreamNavigator> pStream = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
2864           if (pStream->SetAngle(st.id))
2865           {
2866             m_dvd.iSelectedVideoStream = st.id;
2867
2868             CDVDMsgPlayerSeek::CMode mode;
2869             mode.time = (int)GetUpdatedTime();
2870             mode.backward = true;
2871             mode.accurate = true;
2872             mode.trickplay = true;
2873             mode.sync = true;
2874             m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2875           }
2876         }
2877         else
2878         {
2879           CloseStream(m_CurrentVideo, false);
2880           OpenStream(m_CurrentVideo, st.demuxerId, st.id, st.source);
2881           CDVDMsgPlayerSeek::CMode mode;
2882           mode.time = (int)GetUpdatedTime();
2883           mode.backward = true;
2884           mode.accurate = true;
2885           mode.trickplay = true;
2886           mode.sync = true;
2887           m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
2888         }
2889       }
2890     }
2891     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_SUBTITLESTREAM))
2892     {
2893       auto pMsg2 = std::static_pointer_cast<CDVDMsgPlayerSetSubtitleStream>(pMsg);
2894
2895       SelectionStream& st = m_SelectionStreams.Get(STREAM_SUBTITLE, pMsg2->GetStreamId());
2896       if(st.source != STREAM_SOURCE_NONE)
2897       {
2898         if(st.source == STREAM_SOURCE_NAV && m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
2899         {
2900           std::shared_ptr<CDVDInputStreamNavigator> pStream = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
2901           if(pStream->SetActiveSubtitleStream(st.id))
2902           {
2903             m_dvd.iSelectedSPUStream = -1;
2904             CloseStream(m_CurrentSubtitle, false);
2905           }
2906         }
2907         else
2908         {
2909           CloseStream(m_CurrentSubtitle, false);
2910           OpenStream(m_CurrentSubtitle, st.demuxerId, st.id, st.source);
2911         }
2912       }
2913     }
2914     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_SUBTITLESTREAM_VISIBLE))
2915     {
2916       bool isVisible = std::static_pointer_cast<CDVDMsgBool>(pMsg)->m_value;
2917
2918       // SetEnableStream only if not visible, when visible OpenStream already implied that stream is enabled
2919       if (!isVisible)
2920         SetEnableStream(m_CurrentSubtitle, false);
2921
2922       SetSubtitleVisibleInternal(isVisible);
2923     }
2924     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_PROGRAM))
2925     {
2926       auto msg = std::static_pointer_cast<CDVDMsgInt>(pMsg);
2927       if (m_pDemuxer)
2928       {
2929         m_pDemuxer->SetProgram(msg->m_value);
2930         FlushBuffers(DVD_NOPTS_VALUE, false, true);
2931       }
2932     }
2933     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_STATE))
2934     {
2935       SetCaching(CACHESTATE_FLUSH);
2936
2937       auto pMsgPlayerSetState = std::static_pointer_cast<CDVDMsgPlayerSetState>(pMsg);
2938
2939       if (std::shared_ptr<CDVDInputStream::IMenus> ptr = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream))
2940       {
2941         if(ptr->SetState(pMsgPlayerSetState->GetState()))
2942         {
2943           m_dvd.state = DVDSTATE_NORMAL;
2944           m_dvd.iDVDStillStartTime = {};
2945           m_dvd.iDVDStillTime = 0ms;
2946         }
2947       }
2948
2949       m_processInfo->SeekFinished(0);
2950     }
2951     else if (pMsg->IsType(CDVDMsg::GENERAL_FLUSH))
2952     {
2953       FlushBuffers(DVD_NOPTS_VALUE, true, true);
2954     }
2955     else if (pMsg->IsType(CDVDMsg::PLAYER_SETSPEED))
2956     {
2957       int speed = std::static_pointer_cast<CDVDMsgPlayerSetSpeed>(pMsg)->GetSpeed();
2958
2959       // correct our current clock, as it would start going wrong otherwise
2960       if (m_State.timestamp > 0)
2961       {
2962         double offset;
2963         offset = m_clock.GetAbsoluteClock() - m_State.timestamp;
2964         offset *= m_playSpeed / DVD_PLAYSPEED_NORMAL;
2965         offset = DVD_TIME_TO_MSEC(offset);
2966         if (offset > 1000)
2967           offset = 1000;
2968         if (offset < -1000)
2969           offset = -1000;
2970         m_State.time += offset;
2971         m_State.timestamp = m_clock.GetAbsoluteClock();
2972       }
2973
2974       if (speed != DVD_PLAYSPEED_PAUSE && m_playSpeed != DVD_PLAYSPEED_PAUSE && speed != m_playSpeed)
2975       {
2976         m_callback.OnPlayBackSpeedChanged(speed / DVD_PLAYSPEED_NORMAL);
2977         m_processInfo->SeekFinished(0);
2978       }
2979
2980       if (m_pInputStream->IsStreamType(DVDSTREAM_TYPE_PVRMANAGER) && speed != m_playSpeed)
2981       {
2982         std::shared_ptr<CInputStreamPVRBase> pvrinputstream = std::static_pointer_cast<CInputStreamPVRBase>(m_pInputStream);
2983         pvrinputstream->Pause(speed == 0);
2984       }
2985
2986       // do a seek after rewind, clock is not in sync with current pts
2987       if ((speed == DVD_PLAYSPEED_NORMAL) &&
2988           (m_playSpeed != DVD_PLAYSPEED_NORMAL) &&
2989           (m_playSpeed != DVD_PLAYSPEED_PAUSE))
2990       {
2991         double iTime = m_VideoPlayerVideo->GetCurrentPts();
2992         if (iTime == DVD_NOPTS_VALUE)
2993           iTime = m_clock.GetClock();
2994         iTime = (iTime + m_State.time_offset) / 1000;
2995
2996         CDVDMsgPlayerSeek::CMode mode;
2997         mode.time = iTime;
2998         mode.backward = m_playSpeed < 0;
2999         mode.accurate = true;
3000         mode.trickplay = true;
3001         mode.sync = true;
3002         mode.restore = false;
3003         m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
3004       }
3005
3006       if (std::static_pointer_cast<CDVDMsgPlayerSetSpeed>(pMsg)->IsTempo())
3007         m_processInfo->SetTempo(static_cast<float>(speed) / DVD_PLAYSPEED_NORMAL);
3008       else
3009         m_processInfo->SetSpeed(static_cast<float>(speed) / DVD_PLAYSPEED_NORMAL);
3010
3011       m_processInfo->SetFrameAdvance(false);
3012
3013       m_playSpeed = speed;
3014
3015       m_caching = CACHESTATE_DONE;
3016       m_clock.SetSpeed(speed);
3017       m_VideoPlayerAudio->SetSpeed(speed);
3018       m_VideoPlayerVideo->SetSpeed(speed);
3019       m_streamPlayerSpeed = speed;
3020     }
3021     else if (pMsg->IsType(CDVDMsg::PLAYER_FRAME_ADVANCE))
3022     {
3023       if (m_playSpeed == DVD_PLAYSPEED_PAUSE)
3024       {
3025         int frames = std::static_pointer_cast<CDVDMsgInt>(pMsg)->m_value;
3026         double time = DVD_TIME_BASE / static_cast<double>(m_processInfo->GetVideoFps()) * frames;
3027         m_processInfo->SetFrameAdvance(true);
3028         m_clock.Advance(time);
3029       }
3030     }
3031     else if (pMsg->IsType(CDVDMsg::GENERAL_GUI_ACTION))
3032       OnAction(std::static_pointer_cast<CDVDMsgType<CAction>>(pMsg)->m_value);
3033     else if (pMsg->IsType(CDVDMsg::PLAYER_STARTED))
3034     {
3035       SStartMsg& msg = std::static_pointer_cast<CDVDMsgType<SStartMsg>>(pMsg)->m_value;
3036       if (msg.player == VideoPlayer_AUDIO)
3037       {
3038         m_CurrentAudio.syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
3039         m_CurrentAudio.cachetime = msg.cachetime;
3040         m_CurrentAudio.cachetotal = msg.cachetotal;
3041         m_CurrentAudio.starttime = msg.timestamp;
3042       }
3043       if (msg.player == VideoPlayer_VIDEO)
3044       {
3045         m_CurrentVideo.syncState = IDVDStreamPlayer::SYNC_WAITSYNC;
3046         m_CurrentVideo.cachetime = msg.cachetime;
3047         m_CurrentVideo.cachetotal = msg.cachetotal;
3048         m_CurrentVideo.starttime = msg.timestamp;
3049       }
3050       CLog::Log(LOGDEBUG, "CVideoPlayer::HandleMessages - player started {}", msg.player);
3051     }
3052     else if (pMsg->IsType(CDVDMsg::PLAYER_REPORT_STATE))
3053     {
3054       SStateMsg& msg = std::static_pointer_cast<CDVDMsgType<SStateMsg>>(pMsg)->m_value;
3055       if (msg.player == VideoPlayer_AUDIO)
3056       {
3057         m_CurrentAudio.syncState = msg.syncState;
3058       }
3059       if (msg.player == VideoPlayer_VIDEO)
3060       {
3061         m_CurrentVideo.syncState = msg.syncState;
3062       }
3063       CLog::Log(LOGDEBUG, "CVideoPlayer::HandleMessages - player {} reported state: {}", msg.player,
3064                 msg.syncState);
3065     }
3066     else if (pMsg->IsType(CDVDMsg::SUBTITLE_ADDFILE))
3067     {
3068       int id = AddSubtitleFile(std::static_pointer_cast<CDVDMsgType<std::string>>(pMsg)->m_value);
3069       if (id >= 0)
3070       {
3071         SetSubtitle(id);
3072         SetSubtitleVisibleInternal(true);
3073       }
3074     }
3075     else if (pMsg->IsType(CDVDMsg::GENERAL_SYNCHRONIZE))
3076     {
3077       if (std::static_pointer_cast<CDVDMsgGeneralSynchronize>(pMsg)->Wait(100ms, SYNCSOURCE_PLAYER))
3078         CLog::Log(LOGDEBUG, "CVideoPlayer - CDVDMsg::GENERAL_SYNCHRONIZE");
3079     }
3080     else if (pMsg->IsType(CDVDMsg::PLAYER_AVCHANGE))
3081     {
3082       CServiceBroker::GetDataCacheCore().SignalAudioInfoChange();
3083       CServiceBroker::GetDataCacheCore().SignalVideoInfoChange();
3084       CServiceBroker::GetDataCacheCore().SignalSubtitleInfoChange();
3085       IPlayerCallback *cb = &m_callback;
3086       m_outboundEvents->Submit([=]() {
3087         cb->OnAVChange();
3088       });
3089     }
3090     else if (pMsg->IsType(CDVDMsg::PLAYER_ABORT))
3091     {
3092       CLog::Log(LOGDEBUG, "CVideoPlayer - CDVDMsg::PLAYER_ABORT");
3093       m_bAbortRequest = true;
3094     }
3095     else if (pMsg->IsType(CDVDMsg::PLAYER_SET_UPDATE_STREAM_DETAILS))
3096       m_UpdateStreamDetails = true;
3097   }
3098 }
3099
3100 void CVideoPlayer::SetCaching(ECacheState state)
3101 {
3102   if(state == CACHESTATE_FLUSH)
3103   {
3104     CacheInfo cache = GetCachingTimes();
3105     if (cache.valid)
3106       state = CACHESTATE_FULL;
3107     else
3108       state = CACHESTATE_INIT;
3109   }
3110
3111   if(m_caching == state)
3112     return;
3113
3114   CLog::Log(LOGDEBUG, "CVideoPlayer::SetCaching - caching state {}", state);
3115   if (state == CACHESTATE_FULL ||
3116       state == CACHESTATE_INIT)
3117   {
3118     m_clock.SetSpeed(DVD_PLAYSPEED_PAUSE);
3119
3120     m_VideoPlayerAudio->SetSpeed(DVD_PLAYSPEED_PAUSE);
3121     m_VideoPlayerVideo->SetSpeed(DVD_PLAYSPEED_PAUSE);
3122     m_streamPlayerSpeed = DVD_PLAYSPEED_PAUSE;
3123
3124     m_cachingTimer.Set(5000ms);
3125   }
3126
3127   if (state == CACHESTATE_PLAY ||
3128      (state == CACHESTATE_DONE && m_caching != CACHESTATE_PLAY))
3129   {
3130     m_clock.SetSpeed(m_playSpeed);
3131     m_VideoPlayerAudio->SetSpeed(m_playSpeed);
3132     m_VideoPlayerVideo->SetSpeed(m_playSpeed);
3133     m_streamPlayerSpeed = m_playSpeed;
3134   }
3135   m_caching = state;
3136
3137   m_clock.SetSpeedAdjust(0);
3138 }
3139
3140 void CVideoPlayer::SetPlaySpeed(int speed)
3141 {
3142   if (IsPlaying())
3143   {
3144     CDVDMsgPlayerSetSpeed::SpeedParams params = { speed, false };
3145     m_messenger.Put(std::make_shared<CDVDMsgPlayerSetSpeed>(params));
3146   }
3147   else
3148   {
3149     m_playSpeed = speed;
3150     m_streamPlayerSpeed = speed;
3151   }
3152 }
3153
3154 bool CVideoPlayer::CanPause() const
3155 {
3156   std::unique_lock<CCriticalSection> lock(m_StateSection);
3157   return m_State.canpause;
3158 }
3159
3160 void CVideoPlayer::Pause()
3161 {
3162   // toggle between pause and normal speed
3163   if (m_processInfo->GetNewSpeed() == 0)
3164   {
3165     SetSpeed(1);
3166   }
3167   else
3168   {
3169     SetSpeed(0);
3170   }
3171 }
3172
3173 bool CVideoPlayer::HasVideo() const
3174 {
3175   return m_HasVideo;
3176 }
3177
3178 bool CVideoPlayer::HasAudio() const
3179 {
3180   return m_HasAudio;
3181 }
3182
3183 bool CVideoPlayer::HasRDS() const
3184 {
3185   return m_CurrentRadioRDS.id >= 0;
3186 }
3187
3188 bool CVideoPlayer::HasID3() const
3189 {
3190   return m_CurrentAudioID3.id >= 0;
3191 }
3192
3193 bool CVideoPlayer::IsPassthrough() const
3194 {
3195   return m_VideoPlayerAudio->IsPassthrough();
3196 }
3197
3198 bool CVideoPlayer::CanSeek() const
3199 {
3200   std::unique_lock<CCriticalSection> lock(m_StateSection);
3201   return m_State.canseek;
3202 }
3203
3204 void CVideoPlayer::Seek(bool bPlus, bool bLargeStep, bool bChapterOverride)
3205 {
3206   if (!m_State.canseek)
3207     return;
3208
3209   if (bLargeStep && bChapterOverride && GetChapter() > 0 && GetChapterCount() > 1)
3210   {
3211     if (!bPlus)
3212     {
3213       SeekChapter(GetPreviousChapter());
3214       return;
3215     }
3216     else if (GetChapter() < GetChapterCount())
3217     {
3218       SeekChapter(GetChapter() + 1);
3219       return;
3220     }
3221   }
3222
3223   int64_t seekTarget;
3224   const std::shared_ptr<CAdvancedSettings> advancedSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
3225   if (advancedSettings->m_videoUseTimeSeeking && m_processInfo->GetMaxTime() > 2000 * advancedSettings->m_videoTimeSeekForwardBig)
3226   {
3227     if (bLargeStep)
3228       seekTarget = bPlus ? advancedSettings->m_videoTimeSeekForwardBig :
3229                            advancedSettings->m_videoTimeSeekBackwardBig;
3230     else
3231       seekTarget = bPlus ? advancedSettings->m_videoTimeSeekForward :
3232                            advancedSettings->m_videoTimeSeekBackward;
3233     seekTarget *= 1000;
3234     seekTarget += GetTime();
3235   }
3236   else
3237   {
3238     int percent;
3239     if (bLargeStep)
3240       percent = bPlus ? advancedSettings->m_videoPercentSeekForwardBig : advancedSettings->m_videoPercentSeekBackwardBig;
3241     else
3242       percent = bPlus ? advancedSettings->m_videoPercentSeekForward : advancedSettings->m_videoPercentSeekBackward;
3243     seekTarget = static_cast<int64_t>(m_processInfo->GetMaxTime() * (GetPercentage() + percent) / 100);
3244   }
3245
3246   bool restore = true;
3247
3248   int64_t time = GetTime();
3249   if(g_application.CurrentFileItem().IsStack() &&
3250      (seekTarget > m_processInfo->GetMaxTime() || seekTarget < 0))
3251   {
3252     g_application.SeekTime((seekTarget - time) * 0.001 + g_application.GetTime());
3253     // warning, don't access any VideoPlayer variables here as
3254     // the VideoPlayer object may have been destroyed
3255     return;
3256   }
3257
3258   CDVDMsgPlayerSeek::CMode mode;
3259   mode.time = (int)seekTarget;
3260   mode.backward = !bPlus;
3261   mode.accurate = false;
3262   mode.restore = restore;
3263   mode.trickplay = false;
3264   mode.sync = true;
3265
3266   m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
3267   SynchronizeDemuxer();
3268   if (seekTarget < 0)
3269     seekTarget = 0;
3270   m_callback.OnPlayBackSeek(seekTarget, seekTarget - time);
3271 }
3272
3273 bool CVideoPlayer::SeekScene(Direction seekDirection)
3274 {
3275   if (!m_Edl.HasSceneMarker())
3276     return false;
3277
3278   /*
3279    * There is a 5 second grace period applied when seeking for scenes backwards. If there is no
3280    * grace period applied it is impossible to go backwards past a scene marker.
3281    */
3282   auto clock = std::chrono::milliseconds(GetTime());
3283   if (seekDirection == Direction::BACKWARD && clock > 5s) // 5 seconds
3284     clock -= 5s;
3285
3286   const std::optional<std::chrono::milliseconds> sceneMarker =
3287       m_Edl.GetNextSceneMarker(seekDirection, clock);
3288   if (sceneMarker)
3289   {
3290     /*
3291      * Seeking is flushed and inaccurate, just like Seek()
3292      */
3293     CDVDMsgPlayerSeek::CMode mode;
3294     mode.time = sceneMarker.value().count();
3295     mode.backward = seekDirection == Direction::BACKWARD;
3296     mode.accurate = false;
3297     mode.restore = false;
3298     mode.trickplay = false;
3299     mode.sync = true;
3300
3301     m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
3302     SynchronizeDemuxer();
3303     return true;
3304   }
3305   return false;
3306 }
3307
3308 void CVideoPlayer::GetGeneralInfo(std::string& strGeneralInfo)
3309 {
3310   if (!m_bStop)
3311   {
3312     double apts = m_VideoPlayerAudio->GetCurrentPts();
3313     double vpts = m_VideoPlayerVideo->GetCurrentPts();
3314     double dDiff = 0;
3315
3316     if (apts != DVD_NOPTS_VALUE && vpts != DVD_NOPTS_VALUE)
3317       dDiff = (apts - vpts) / DVD_TIME_BASE;
3318
3319     std::string strBuf;
3320     std::unique_lock<CCriticalSection> lock(m_StateSection);
3321     if (m_State.cache_bytes >= 0)
3322     {
3323       strBuf += StringUtils::Format("forward: {} / {:2.0f}% / {:6.3f}s / {:.3f}%",
3324                                     StringUtils::SizeToString(m_State.cache_bytes),
3325                                     m_State.cache_level * 100.0, m_State.cache_time,
3326                                     m_State.cache_offset * 100.0);
3327     }
3328
3329     strGeneralInfo = StringUtils::Format("Player: a/v:{: 6.3f}, {}", dDiff, strBuf);
3330   }
3331 }
3332
3333 void CVideoPlayer::SeekPercentage(float iPercent)
3334 {
3335   int64_t iTotalTime = m_processInfo->GetMaxTime();
3336
3337   if (!iTotalTime)
3338     return;
3339
3340   SeekTime((int64_t)(iTotalTime * iPercent / 100));
3341 }
3342
3343 float CVideoPlayer::GetPercentage()
3344 {
3345   int64_t iTotalTime = m_processInfo->GetMaxTime();
3346
3347   if (!iTotalTime)
3348     return 0.0f;
3349
3350   return GetTime() * 100 / (float)iTotalTime;
3351 }
3352
3353 float CVideoPlayer::GetCachePercentage() const
3354 {
3355   std::unique_lock<CCriticalSection> lock(m_StateSection);
3356   return (float) (m_State.cache_offset * 100); // NOTE: Percentage returned is relative
3357 }
3358
3359 void CVideoPlayer::SetAVDelay(float fValue)
3360 {
3361   m_processInfo->GetVideoSettingsLocked().SetAudioDelay(fValue);
3362   m_renderManager.SetDelay(static_cast<int>(fValue * 1000.0f));
3363 }
3364
3365 float CVideoPlayer::GetAVDelay()
3366 {
3367   return static_cast<float>(m_renderManager.GetDelay()) / 1000.0f;
3368 }
3369
3370 void CVideoPlayer::SetSubTitleDelay(float fValue)
3371 {
3372   m_processInfo->GetVideoSettingsLocked().SetSubtitleDelay(fValue);
3373   m_VideoPlayerVideo->SetSubtitleDelay(static_cast<double>(-fValue) * DVD_TIME_BASE);
3374 }
3375
3376 float CVideoPlayer::GetSubTitleDelay()
3377 {
3378   return (float) -m_VideoPlayerVideo->GetSubtitleDelay() / DVD_TIME_BASE;
3379 }
3380
3381 bool CVideoPlayer::GetSubtitleVisible() const
3382 {
3383   if (m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
3384   {
3385     std::shared_ptr<CDVDInputStreamNavigator> pStream = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
3386     return pStream->IsSubtitleStreamEnabled();
3387   }
3388
3389   return m_VideoPlayerVideo->IsSubtitleEnabled();
3390 }
3391
3392 void CVideoPlayer::SetSubtitleVisible(bool bVisible)
3393 {
3394   m_messenger.Put(
3395       std::make_shared<CDVDMsgBool>(CDVDMsg::PLAYER_SET_SUBTITLESTREAM_VISIBLE, bVisible));
3396   m_processInfo->GetVideoSettingsLocked().SetSubtitleVisible(bVisible);
3397 }
3398
3399 void CVideoPlayer::SetEnableStream(CCurrentStream& current, bool isEnabled)
3400 {
3401   if (m_pDemuxer && STREAM_SOURCE_MASK(current.source) == STREAM_SOURCE_DEMUX)
3402     m_pDemuxer->EnableStream(current.demuxerId, current.id, isEnabled);
3403 }
3404
3405 void CVideoPlayer::SetSubtitleVisibleInternal(bool bVisible)
3406 {
3407   m_VideoPlayerVideo->EnableSubtitle(bVisible);
3408
3409   if (m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
3410     std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream)->EnableSubtitleStream(bVisible);
3411
3412   CServiceBroker::GetDataCacheCore().SignalSubtitleInfoChange();
3413 }
3414
3415 void CVideoPlayer::SetSubtitleVerticalPosition(int value, bool save)
3416 {
3417   m_processInfo->GetVideoSettingsLocked().SetSubtitleVerticalPosition(value, save);
3418   m_renderManager.SetSubtitleVerticalPosition(value, save);
3419 }
3420
3421 std::shared_ptr<TextCacheStruct_t> CVideoPlayer::GetTeletextCache()
3422 {
3423   if (m_CurrentTeletext.id < 0)
3424     return nullptr;
3425
3426   return m_VideoPlayerTeletext->GetTeletextCache();
3427 }
3428
3429 bool CVideoPlayer::HasTeletextCache() const
3430 {
3431   return m_CurrentTeletext.id >= 0;
3432 }
3433
3434 void CVideoPlayer::LoadPage(int p, int sp, unsigned char* buffer)
3435 {
3436   if (m_CurrentTeletext.id < 0)
3437       return;
3438
3439   return m_VideoPlayerTeletext->LoadPage(p, sp, buffer);
3440 }
3441
3442 void CVideoPlayer::SeekTime(int64_t iTime)
3443 {
3444   int64_t seekOffset = iTime - GetTime();
3445
3446   CDVDMsgPlayerSeek::CMode mode;
3447   mode.time = static_cast<double>(iTime);
3448   mode.backward = true;
3449   mode.accurate = true;
3450   mode.trickplay = false;
3451   mode.sync = true;
3452
3453   m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
3454   SynchronizeDemuxer();
3455   m_callback.OnPlayBackSeek(iTime, seekOffset);
3456   m_processInfo->SeekFinished(seekOffset);
3457 }
3458
3459 bool CVideoPlayer::SeekTimeRelative(int64_t iTime)
3460 {
3461   int64_t abstime = GetTime() + iTime;
3462
3463   // if the file has EDL cuts we can't rely on m_clock for relative seeks
3464   // EDL cuts remove time from the original file, hence we might seek to
3465   // positions too far from the current m_clock position. Seek to absolute
3466   // time instead
3467   if (m_Edl.HasCuts())
3468   {
3469     SeekTime(abstime);
3470     return true;
3471   }
3472
3473   CDVDMsgPlayerSeek::CMode mode;
3474   mode.time = (int)iTime;
3475   mode.relative = true;
3476   mode.backward = (iTime < 0) ? true : false;
3477   mode.accurate = false;
3478   mode.trickplay = false;
3479   mode.sync = true;
3480
3481   m_messenger.Put(std::make_shared<CDVDMsgPlayerSeek>(mode));
3482   m_processInfo->SetStateSeeking(true);
3483
3484   m_callback.OnPlayBackSeek(abstime, iTime);
3485   m_processInfo->SeekFinished(iTime);
3486   return true;
3487 }
3488
3489 // return the time in milliseconds
3490 int64_t CVideoPlayer::GetTime()
3491 {
3492   std::unique_lock<CCriticalSection> lock(m_StateSection);
3493   return llrint(m_State.time);
3494 }
3495
3496 void CVideoPlayer::SetSpeed(float speed)
3497 {
3498   // can't rewind in menu as seeking isn't possible
3499   // forward is fine
3500   if (speed < 0 && IsInMenu())
3501     return;
3502
3503   if (!CanSeek() && !CanPause())
3504     return;
3505
3506   int iSpeed = static_cast<int>(speed * DVD_PLAYSPEED_NORMAL);
3507
3508   if (!CanSeek())
3509   {
3510     if ((iSpeed != DVD_PLAYSPEED_NORMAL) && (iSpeed != DVD_PLAYSPEED_PAUSE))
3511       return;
3512   }
3513
3514   float currentSpeed = m_processInfo->GetNewSpeed();
3515   m_processInfo->SetNewSpeed(speed);
3516   if (iSpeed != currentSpeed)
3517   {
3518     if (iSpeed == DVD_PLAYSPEED_NORMAL)
3519       m_callback.OnPlayBackResumed();
3520     else if (iSpeed == DVD_PLAYSPEED_PAUSE)
3521       m_callback.OnPlayBackPaused();
3522
3523     if (iSpeed == DVD_PLAYSPEED_NORMAL)
3524     {
3525       float currentTempo = m_processInfo->GetNewTempo();
3526       if (currentTempo != 1.0f)
3527       {
3528         SetTempo(currentTempo);
3529         return;
3530       }
3531     }
3532     SetPlaySpeed(iSpeed);
3533   }
3534 }
3535
3536 void CVideoPlayer::SetTempo(float tempo)
3537 {
3538   tempo = floor(tempo * 100.0f + 0.5f) / 100.0f;
3539   if (m_processInfo->IsTempoAllowed(tempo))
3540   {
3541     int speed = tempo * DVD_PLAYSPEED_NORMAL;
3542     CDVDMsgPlayerSetSpeed::SpeedParams params = { speed, true };
3543     m_messenger.Put(std::make_shared<CDVDMsgPlayerSetSpeed>(params));
3544
3545     m_processInfo->SetNewTempo(tempo);
3546   }
3547 }
3548
3549 void CVideoPlayer::FrameAdvance(int frames)
3550 {
3551   float currentSpeed = m_processInfo->GetNewSpeed();
3552   if (currentSpeed != DVD_PLAYSPEED_PAUSE)
3553     return;
3554
3555   m_messenger.Put(std::make_shared<CDVDMsgInt>(CDVDMsg::PLAYER_FRAME_ADVANCE, frames));
3556 }
3557
3558 bool CVideoPlayer::SupportsTempo() const
3559 {
3560   return m_State.cantempo;
3561 }
3562
3563 bool CVideoPlayer::OpenStream(CCurrentStream& current, int64_t demuxerId, int iStream, int source, bool reset /*= true*/)
3564 {
3565   CDemuxStream* stream = NULL;
3566   CDVDStreamInfo hint;
3567
3568   CLog::Log(LOGINFO, "Opening stream: {} source: {}", iStream, source);
3569
3570   if(STREAM_SOURCE_MASK(source) == STREAM_SOURCE_DEMUX_SUB)
3571   {
3572     int index = m_SelectionStreams.TypeIndexOf(current.type, source, demuxerId, iStream);
3573     if (index < 0)
3574       return false;
3575     const SelectionStream& st = m_SelectionStreams.Get(current.type, index);
3576
3577     CLog::Log(LOGINFO, "Opening Subtitle file: {}", CURL::GetRedacted(st.filename));
3578     m_pSubtitleDemuxer.reset();
3579     const auto demux = m_subtitleDemuxerMap.find(demuxerId);
3580     if (demux == m_subtitleDemuxerMap.end())
3581     {
3582       CLog::Log(LOGINFO, "No demuxer found for file {}", CURL::GetRedacted(st.filename));
3583       return false;
3584     }
3585
3586     m_pSubtitleDemuxer = demux->second;
3587
3588     double pts = m_VideoPlayerVideo->GetCurrentPts();
3589     if(pts == DVD_NOPTS_VALUE)
3590       pts = m_CurrentVideo.dts;
3591     if(pts == DVD_NOPTS_VALUE)
3592       pts = 0;
3593     pts += m_offset_pts;
3594     if (!m_pSubtitleDemuxer->SeekTime((int)(1000.0 * pts / (double)DVD_TIME_BASE)))
3595       CLog::Log(LOGDEBUG, "{} - failed to start subtitle demuxing from: {:f}", __FUNCTION__, pts);
3596     stream = m_pSubtitleDemuxer->GetStream(demuxerId, iStream);
3597     if(!stream || stream->disabled)
3598       return false;
3599
3600     m_pSubtitleDemuxer->EnableStream(demuxerId, iStream, true);
3601
3602     hint.Assign(*stream, true);
3603   }
3604   else if(STREAM_SOURCE_MASK(source) == STREAM_SOURCE_TEXT)
3605   {
3606     int index = m_SelectionStreams.TypeIndexOf(current.type, source, demuxerId, iStream);
3607     if(index < 0)
3608       return false;
3609
3610     hint.Clear();
3611     hint.filename = m_SelectionStreams.Get(current.type, index).filename;
3612     hint.fpsscale = m_CurrentVideo.hint.fpsscale;
3613     hint.fpsrate  = m_CurrentVideo.hint.fpsrate;
3614   }
3615   else if(STREAM_SOURCE_MASK(source) == STREAM_SOURCE_DEMUX)
3616   {
3617     if(!m_pDemuxer)
3618       return false;
3619
3620     m_pDemuxer->OpenStream(demuxerId, iStream);
3621
3622     stream = m_pDemuxer->GetStream(demuxerId, iStream);
3623     if (!stream || stream->disabled)
3624       return false;
3625
3626     hint.Assign(*stream, true);
3627
3628     if(m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
3629       hint.filename = "dvd";
3630   }
3631   else if(STREAM_SOURCE_MASK(source) == STREAM_SOURCE_VIDEOMUX)
3632   {
3633     if(!m_pCCDemuxer)
3634       return false;
3635
3636     stream = m_pCCDemuxer->GetStream(iStream);
3637     if(!stream || stream->disabled)
3638       return false;
3639
3640     hint.Assign(*stream, false);
3641   }
3642
3643   bool res;
3644   switch(current.type)
3645   {
3646     case STREAM_AUDIO:
3647       res = OpenAudioStream(hint, reset);
3648       break;
3649     case STREAM_VIDEO:
3650       res = OpenVideoStream(hint, reset);
3651       break;
3652     case STREAM_SUBTITLE:
3653       res = OpenSubtitleStream(hint);
3654       break;
3655     case STREAM_TELETEXT:
3656       res = OpenTeletextStream(hint);
3657       break;
3658     case STREAM_RADIO_RDS:
3659       res = OpenRadioRDSStream(hint);
3660       break;
3661     case STREAM_AUDIO_ID3:
3662       res = OpenAudioID3Stream(hint);
3663       break;
3664     default:
3665       res = false;
3666       break;
3667   }
3668
3669   if (res)
3670   {
3671     int oldId = current.id;
3672     current.id = iStream;
3673     current.demuxerId = demuxerId;
3674     current.source = source;
3675     current.hint = hint;
3676     current.stream = (void*)stream;
3677     current.lastdts = DVD_NOPTS_VALUE;
3678     if (oldId >= 0 && current.avsync != CCurrentStream::AV_SYNC_FORCE)
3679       current.avsync = CCurrentStream::AV_SYNC_CHECK;
3680     if(stream)
3681       current.changes = stream->changes;
3682   }
3683   else
3684   {
3685     if(stream)
3686     {
3687       /* mark stream as disabled, to disallow further attempts*/
3688       CLog::Log(LOGWARNING, "{} - Unsupported stream {}. Stream disabled.", __FUNCTION__,
3689                 stream->uniqueId);
3690       stream->disabled = true;
3691     }
3692   }
3693
3694   UpdateContentState();
3695   CServiceBroker::GetDataCacheCore().SignalAudioInfoChange();
3696   CServiceBroker::GetDataCacheCore().SignalVideoInfoChange();
3697   CServiceBroker::GetDataCacheCore().SignalSubtitleInfoChange();
3698
3699   return res;
3700 }
3701
3702 bool CVideoPlayer::OpenAudioStream(CDVDStreamInfo& hint, bool reset)
3703 {
3704   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentAudio.player);
3705   if(player == nullptr)
3706     return false;
3707
3708   if(m_CurrentAudio.id < 0 ||
3709      m_CurrentAudio.hint != hint)
3710   {
3711     if (!player->OpenStream(hint))
3712       return false;
3713
3714     player->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, m_displayLost), 1);
3715
3716     static_cast<IDVDStreamPlayerAudio*>(player)->SetSpeed(m_streamPlayerSpeed);
3717     m_CurrentAudio.syncState = IDVDStreamPlayer::SYNC_STARTING;
3718     m_CurrentAudio.packets = 0;
3719   }
3720   else if (reset)
3721     player->SendMessage(std::make_shared<CDVDMsg>(CDVDMsg::GENERAL_RESET), 0);
3722
3723   m_HasAudio = true;
3724
3725   static_cast<IDVDStreamPlayerAudio*>(player)->SendMessage(
3726       std::make_shared<CDVDMsg>(CDVDMsg::PLAYER_REQUEST_STATE), 1);
3727
3728   return true;
3729 }
3730
3731 bool CVideoPlayer::OpenVideoStream(CDVDStreamInfo& hint, bool reset)
3732 {
3733   if (m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
3734   {
3735     /* set aspect ratio as requested by navigator for dvd's */
3736     float aspect = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream)->GetVideoAspectRatio();
3737     if (aspect != 0.0f)
3738     {
3739       hint.aspect = static_cast<double>(aspect);
3740       hint.forced_aspect = true;
3741     }
3742     hint.dvd = true;
3743   }
3744   else if (m_pInputStream && m_pInputStream->IsStreamType(DVDSTREAM_TYPE_PVRMANAGER))
3745   {
3746     // set framerate if not set by demuxer
3747     if (hint.fpsrate == 0 || hint.fpsscale == 0)
3748     {
3749       int fpsidx = CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_PVRPLAYBACK_FPS);
3750       if (fpsidx == 1)
3751       {
3752         hint.fpsscale = 1000;
3753         hint.fpsrate = 50000;
3754       }
3755       else if (fpsidx == 2)
3756       {
3757         hint.fpsscale = 1001;
3758         hint.fpsrate = 60000;
3759       }
3760     }
3761   }
3762
3763   std::shared_ptr<CDVDInputStream::IMenus> pMenus = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream);
3764   if(pMenus && pMenus->IsInMenu())
3765     hint.stills = true;
3766
3767   if (hint.stereo_mode.empty())
3768   {
3769     CGUIComponent *gui = CServiceBroker::GetGUI();
3770     if (gui != nullptr)
3771     {
3772       const CStereoscopicsManager &stereoscopicsManager = gui->GetStereoscopicsManager();
3773       hint.stereo_mode = stereoscopicsManager.DetectStereoModeByString(m_item.GetPath());
3774     }
3775   }
3776
3777   if (hint.flags & AV_DISPOSITION_ATTACHED_PIC)
3778     return false;
3779
3780   // set desired refresh rate
3781   if (m_CurrentVideo.id < 0 && m_playerOptions.fullscreen &&
3782       CServiceBroker::GetWinSystem()->GetGfxContext().IsFullScreenRoot() && hint.fpsrate != 0 &&
3783       hint.fpsscale != 0)
3784   {
3785     if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetInt(CSettings::SETTING_VIDEOPLAYER_ADJUSTREFRESHRATE) != ADJUST_REFRESHRATE_OFF)
3786     {
3787       const double framerate = DVD_TIME_BASE / CDVDCodecUtils::NormalizeFrameduration(
3788                                                    (double)DVD_TIME_BASE * hint.fpsscale /
3789                                                    (hint.fpsrate * (hint.interlaced ? 2 : 1)));
3790
3791       RESOLUTION res = CResolutionUtils::ChooseBestResolution(static_cast<float>(framerate), hint.width, hint.height, !hint.stereo_mode.empty());
3792       CServiceBroker::GetWinSystem()->GetGfxContext().SetVideoResolution(res, false);
3793       m_renderManager.TriggerUpdateResolution(framerate, hint.width, hint.height, hint.stereo_mode);
3794     }
3795   }
3796
3797   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentVideo.player);
3798   if(player == nullptr)
3799     return false;
3800
3801   if(m_CurrentVideo.id < 0 ||
3802      m_CurrentVideo.hint != hint)
3803   {
3804     if (hint.codec == AV_CODEC_ID_MPEG2VIDEO || hint.codec == AV_CODEC_ID_H264)
3805       m_pCCDemuxer.reset();
3806
3807     if (!player->OpenStream(hint))
3808       return false;
3809
3810     player->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, m_displayLost), 1);
3811
3812     // look for any EDL files
3813     m_Edl.Clear();
3814     float fFramesPerSecond = 0.0f;
3815     if (m_CurrentVideo.hint.fpsscale > 0.0f)
3816       fFramesPerSecond = static_cast<float>(m_CurrentVideo.hint.fpsrate) / static_cast<float>(m_CurrentVideo.hint.fpsscale);
3817     m_Edl.ReadEditDecisionLists(m_item, fFramesPerSecond);
3818     CServiceBroker::GetDataCacheCore().SetEditList(m_Edl.GetEditList());
3819     CServiceBroker::GetDataCacheCore().SetCuts(m_Edl.GetCutMarkers());
3820     CServiceBroker::GetDataCacheCore().SetSceneMarkers(m_Edl.GetSceneMarkers());
3821
3822     static_cast<IDVDStreamPlayerVideo*>(player)->SetSpeed(m_streamPlayerSpeed);
3823     m_CurrentVideo.syncState = IDVDStreamPlayer::SYNC_STARTING;
3824     m_CurrentVideo.packets = 0;
3825   }
3826   else if (reset)
3827     player->SendMessage(std::make_shared<CDVDMsg>(CDVDMsg::GENERAL_RESET), 0);
3828
3829   m_HasVideo = true;
3830
3831   static_cast<IDVDStreamPlayerVideo*>(player)->SendMessage(
3832       std::make_shared<CDVDMsg>(CDVDMsg::PLAYER_REQUEST_STATE), 1);
3833
3834   // open CC demuxer if video is mpeg2
3835   if ((hint.codec == AV_CODEC_ID_MPEG2VIDEO || hint.codec == AV_CODEC_ID_H264) && !m_pCCDemuxer)
3836   {
3837     m_pCCDemuxer = std::make_unique<CDVDDemuxCC>(hint.codec);
3838     m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_VIDEOMUX);
3839   }
3840
3841   return true;
3842 }
3843
3844 bool CVideoPlayer::OpenSubtitleStream(const CDVDStreamInfo& hint)
3845 {
3846   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentSubtitle.player);
3847   if(player == nullptr)
3848     return false;
3849
3850   if(m_CurrentSubtitle.id < 0 ||
3851      m_CurrentSubtitle.hint != hint)
3852   {
3853     if (!player->OpenStream(hint))
3854       return false;
3855   }
3856
3857   return true;
3858 }
3859
3860 void CVideoPlayer::AdaptForcedSubtitles()
3861 {
3862   SelectionStream ss = m_SelectionStreams.Get(STREAM_SUBTITLE, GetSubtitle());
3863   if (ss.flags & StreamFlags::FLAG_FORCED)
3864   {
3865     SelectionStream as = m_SelectionStreams.Get(STREAM_AUDIO, GetAudioStream());
3866     bool isVisible = false;
3867     for (const auto &stream : m_SelectionStreams.Get(STREAM_SUBTITLE))
3868     {
3869       if (stream.flags & StreamFlags::FLAG_FORCED && g_LangCodeExpander.CompareISO639Codes(stream.language, as.language))
3870       {
3871         if (OpenStream(m_CurrentSubtitle, stream.demuxerId, stream.id, stream.source))
3872         {
3873           isVisible = true;
3874           break;
3875         }
3876       }
3877     }
3878     // SetEnableStream only if not visible, when visible OpenStream already implied that stream is enabled
3879     if (!isVisible)
3880       SetEnableStream(m_CurrentSubtitle, false);
3881
3882     SetSubtitleVisibleInternal(isVisible);
3883   }
3884 }
3885
3886 bool CVideoPlayer::OpenTeletextStream(CDVDStreamInfo& hint)
3887 {
3888   if (!m_VideoPlayerTeletext->CheckStream(hint))
3889     return false;
3890
3891   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentTeletext.player);
3892   if(player == nullptr)
3893     return false;
3894
3895   if(m_CurrentTeletext.id < 0 ||
3896      m_CurrentTeletext.hint != hint)
3897   {
3898     if (!player->OpenStream(hint))
3899       return false;
3900   }
3901
3902   return true;
3903 }
3904
3905 bool CVideoPlayer::OpenRadioRDSStream(CDVDStreamInfo& hint)
3906 {
3907   if (!m_VideoPlayerRadioRDS->CheckStream(hint))
3908     return false;
3909
3910   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentRadioRDS.player);
3911   if(player == nullptr)
3912     return false;
3913
3914   if(m_CurrentRadioRDS.id < 0 ||
3915      m_CurrentRadioRDS.hint != hint)
3916   {
3917     if (!player->OpenStream(hint))
3918       return false;
3919   }
3920
3921   return true;
3922 }
3923
3924 bool CVideoPlayer::OpenAudioID3Stream(CDVDStreamInfo& hint)
3925 {
3926   if (!m_VideoPlayerAudioID3->CheckStream(hint))
3927     return false;
3928
3929   IDVDStreamPlayer* player = GetStreamPlayer(m_CurrentAudioID3.player);
3930   if (player == nullptr)
3931     return false;
3932
3933   if (m_CurrentAudioID3.id < 0 || m_CurrentAudioID3.hint != hint)
3934   {
3935     if (!player->OpenStream(hint))
3936       return false;
3937   }
3938
3939   return true;
3940 }
3941
3942 bool CVideoPlayer::CloseStream(CCurrentStream& current, bool bWaitForBuffers)
3943 {
3944   if (current.id < 0)
3945     return false;
3946
3947   CLog::Log(LOGINFO, "Closing stream player {}", current.player);
3948
3949   if(bWaitForBuffers)
3950     SetCaching(CACHESTATE_DONE);
3951
3952   SetEnableStream(current, false);
3953
3954   IDVDStreamPlayer* player = GetStreamPlayer(current.player);
3955   if (player)
3956   {
3957     if ((current.type == STREAM_AUDIO && current.syncState != IDVDStreamPlayer::SYNC_INSYNC) ||
3958         (current.type == STREAM_VIDEO && current.syncState != IDVDStreamPlayer::SYNC_INSYNC) ||
3959         m_bAbortRequest)
3960       bWaitForBuffers = false;
3961     player->CloseStream(bWaitForBuffers);
3962   }
3963
3964   current.Clear();
3965   return true;
3966 }
3967
3968 void CVideoPlayer::FlushBuffers(double pts, bool accurate, bool sync)
3969 {
3970   CLog::Log(LOGDEBUG, "CVideoPlayer::FlushBuffers - flushing buffers");
3971
3972   double startpts;
3973   if (accurate)
3974     startpts = pts;
3975   else
3976     startpts = DVD_NOPTS_VALUE;
3977
3978   m_SpeedState.Reset(pts);
3979
3980   if (sync)
3981   {
3982     m_CurrentAudio.inited = false;
3983     m_CurrentAudio.avsync = CCurrentStream::AV_SYNC_FORCE;
3984     m_CurrentAudio.starttime = DVD_NOPTS_VALUE;
3985     m_CurrentVideo.inited = false;
3986     m_CurrentVideo.avsync = CCurrentStream::AV_SYNC_FORCE;
3987     m_CurrentVideo.starttime = DVD_NOPTS_VALUE;
3988     m_CurrentSubtitle.inited = false;
3989     m_CurrentTeletext.inited = false;
3990     m_CurrentRadioRDS.inited  = false;
3991   }
3992
3993   m_CurrentAudio.dts         = DVD_NOPTS_VALUE;
3994   m_CurrentAudio.startpts    = startpts;
3995   m_CurrentAudio.packets = 0;
3996
3997   m_CurrentVideo.dts         = DVD_NOPTS_VALUE;
3998   m_CurrentVideo.startpts    = startpts;
3999   m_CurrentVideo.packets = 0;
4000
4001   m_CurrentSubtitle.dts      = DVD_NOPTS_VALUE;
4002   m_CurrentSubtitle.startpts = startpts;
4003   m_CurrentSubtitle.packets = 0;
4004
4005   m_CurrentTeletext.dts      = DVD_NOPTS_VALUE;
4006   m_CurrentTeletext.startpts = startpts;
4007   m_CurrentTeletext.packets = 0;
4008
4009   m_CurrentRadioRDS.dts      = DVD_NOPTS_VALUE;
4010   m_CurrentRadioRDS.startpts = startpts;
4011   m_CurrentRadioRDS.packets = 0;
4012
4013   m_CurrentAudioID3.dts = DVD_NOPTS_VALUE;
4014   m_CurrentAudioID3.startpts = startpts;
4015   m_CurrentAudioID3.packets = 0;
4016
4017   m_VideoPlayerAudio->Flush(sync);
4018   m_VideoPlayerVideo->Flush(sync);
4019   m_VideoPlayerSubtitle->Flush();
4020   m_VideoPlayerTeletext->Flush();
4021   m_VideoPlayerRadioRDS->Flush();
4022   m_VideoPlayerAudioID3->Flush();
4023
4024   if (m_playSpeed == DVD_PLAYSPEED_NORMAL || m_playSpeed == DVD_PLAYSPEED_PAUSE ||
4025       (m_playSpeed >= DVD_PLAYSPEED_NORMAL * m_processInfo->MinTempoPlatform() &&
4026        m_playSpeed <= DVD_PLAYSPEED_NORMAL * m_processInfo->MaxTempoPlatform()))
4027   {
4028     // make sure players are properly flushed, should put them in stalled state
4029     auto msg = std::make_shared<CDVDMsgGeneralSynchronize>(1s, SYNCSOURCE_AUDIO | SYNCSOURCE_VIDEO);
4030     m_VideoPlayerAudio->SendMessage(msg, 1);
4031     m_VideoPlayerVideo->SendMessage(msg, 1);
4032     msg->Wait(m_bStop, 0);
4033
4034     // purge any pending PLAYER_STARTED messages
4035     m_messenger.Flush(CDVDMsg::PLAYER_STARTED);
4036
4037     // we should now wait for init cache
4038     SetCaching(CACHESTATE_FLUSH);
4039     if (sync)
4040     {
4041       m_CurrentAudio.syncState = IDVDStreamPlayer::SYNC_STARTING;
4042       m_CurrentVideo.syncState = IDVDStreamPlayer::SYNC_STARTING;
4043     }
4044   }
4045
4046   if(pts != DVD_NOPTS_VALUE && sync)
4047     m_clock.Discontinuity(pts);
4048   UpdatePlayState(0);
4049
4050   m_demuxerSpeed = DVD_PLAYSPEED_NORMAL;
4051   if (m_pDemuxer)
4052     m_pDemuxer->SetSpeed(DVD_PLAYSPEED_NORMAL);
4053 }
4054
4055 // since we call ffmpeg functions to decode, this is being called in the same thread as ::Process() is
4056 int CVideoPlayer::OnDiscNavResult(void* pData, int iMessage)
4057 {
4058   if (!m_pInputStream)
4059     return 0;
4060
4061 #if defined(HAVE_LIBBLURAY)
4062   if (m_pInputStream->IsStreamType(DVDSTREAM_TYPE_BLURAY))
4063   {
4064     switch (iMessage)
4065     {
4066     case BD_EVENT_MENU_OVERLAY:
4067       m_overlayContainer.ProcessAndAddOverlayIfValid(
4068           *static_cast<std::shared_ptr<CDVDOverlay>*>(pData));
4069       break;
4070     case BD_EVENT_PLAYLIST_STOP:
4071       m_dvd.state = DVDSTATE_NORMAL;
4072       m_dvd.iDVDStillTime = 0ms;
4073       m_messenger.Put(std::make_shared<CDVDMsg>(CDVDMsg::GENERAL_FLUSH));
4074       break;
4075     case BD_EVENT_AUDIO_STREAM:
4076       m_dvd.iSelectedAudioStream = *static_cast<int*>(pData);
4077       break;
4078
4079     case BD_EVENT_PG_TEXTST_STREAM:
4080       m_dvd.iSelectedSPUStream = *static_cast<int*>(pData);
4081       break;
4082     case BD_EVENT_PG_TEXTST:
4083     {
4084       bool enable = (*static_cast<int*>(pData) != 0);
4085       m_VideoPlayerVideo->EnableSubtitle(enable);
4086     }
4087     break;
4088     case BD_EVENT_STILL_TIME:
4089     {
4090       if (m_dvd.state != DVDSTATE_STILL)
4091       {
4092         // else notify the player we have received a still frame
4093
4094         m_dvd.iDVDStillTime = std::chrono::milliseconds(*static_cast<int*>(pData));
4095         m_dvd.iDVDStillStartTime = std::chrono::steady_clock::now();
4096
4097         if (m_dvd.iDVDStillTime > 0ms)
4098           m_dvd.iDVDStillTime *= 1000;
4099
4100         /* adjust for the output delay in the video queue */
4101         std::chrono::milliseconds time = 0ms;
4102         if (m_CurrentVideo.stream && m_dvd.iDVDStillTime > 0ms)
4103         {
4104           time = std::chrono::milliseconds(
4105               static_cast<int>(m_VideoPlayerVideo->GetOutputDelay() / (DVD_TIME_BASE / 1000)));
4106           if (time < 10000ms && time > 0ms)
4107             m_dvd.iDVDStillTime += time;
4108         }
4109         m_dvd.state = DVDSTATE_STILL;
4110         CLog::Log(LOGDEBUG, "BD_EVENT_STILL_TIME - waiting {} msec, with delay of {} msec",
4111                   m_dvd.iDVDStillTime.count(), time.count());
4112       }
4113     }
4114     break;
4115     case BD_EVENT_STILL:
4116     {
4117       bool on = static_cast<bool>(*static_cast<int*>(pData));
4118       if (on && m_dvd.state != DVDSTATE_STILL)
4119       {
4120         m_dvd.state = DVDSTATE_STILL;
4121         m_dvd.iDVDStillStartTime = std::chrono::steady_clock::now();
4122         m_dvd.iDVDStillTime = 0ms;
4123         CLog::Log(LOGDEBUG, "CDVDPlayer::OnDVDNavResult - libbluray DVDSTATE_STILL start");
4124       }
4125       else if (!on && m_dvd.state == DVDSTATE_STILL)
4126       {
4127         m_dvd.state = DVDSTATE_NORMAL;
4128         m_dvd.iDVDStillStartTime = {};
4129         m_dvd.iDVDStillTime = 0ms;
4130         CLog::Log(LOGDEBUG, "CDVDPlayer::OnDVDNavResult - libbluray DVDSTATE_STILL end");
4131       }
4132     }
4133     break;
4134     case BD_EVENT_MENU_ERROR:
4135     {
4136       m_dvd.state = DVDSTATE_NORMAL;
4137       CLog::Log(LOGDEBUG, "CVideoPlayer::OnDiscNavResult - libbluray menu not supported (DVDSTATE_NORMAL)");
4138       CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(25008), g_localizeStrings.Get(25009));
4139     }
4140     break;
4141     case BD_EVENT_ENC_ERROR:
4142     {
4143       m_dvd.state = DVDSTATE_NORMAL;
4144       CLog::Log(LOGDEBUG, "CVideoPlayer::OnDiscNavResult - libbluray the disc/file is encrypted and can't be played (DVDSTATE_NORMAL)");
4145       CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(16026), g_localizeStrings.Get(29805));
4146     }
4147     break;
4148     default:
4149       break;
4150     }
4151
4152     return 0;
4153   }
4154 #endif
4155
4156   if (m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
4157   {
4158     std::shared_ptr<CDVDInputStreamNavigator> pStream = std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
4159
4160     switch (iMessage)
4161     {
4162     case DVDNAV_STILL_FRAME:
4163       {
4164         //CLog::Log(LOGDEBUG, "DVDNAV_STILL_FRAME");
4165
4166         dvdnav_still_event_t *still_event = static_cast<dvdnav_still_event_t*>(pData);
4167         // should wait the specified time here while we let the player running
4168         // after that call dvdnav_still_skip(m_dvdnav);
4169
4170         if (m_dvd.state != DVDSTATE_STILL)
4171         {
4172           // else notify the player we have received a still frame
4173
4174           if(still_event->length < 0xff)
4175             m_dvd.iDVDStillTime = std::chrono::seconds(still_event->length);
4176           else
4177             m_dvd.iDVDStillTime = 0ms;
4178
4179           m_dvd.iDVDStillStartTime = std::chrono::steady_clock::now();
4180
4181           /* adjust for the output delay in the video queue */
4182           std::chrono::milliseconds time = 0ms;
4183           if (m_CurrentVideo.stream && m_dvd.iDVDStillTime > 0ms)
4184           {
4185             time = std::chrono::milliseconds(
4186                 static_cast<int>(m_VideoPlayerVideo->GetOutputDelay() / (DVD_TIME_BASE / 1000)));
4187             if (time < 10000ms && time > 0ms)
4188               m_dvd.iDVDStillTime += time;
4189           }
4190           m_dvd.state = DVDSTATE_STILL;
4191           CLog::Log(LOGDEBUG, "DVDNAV_STILL_FRAME - waiting {} sec, with delay of {} msec",
4192                     still_event->length, time.count());
4193         }
4194         return NAVRESULT_HOLD;
4195       }
4196       break;
4197     case DVDNAV_SPU_CLUT_CHANGE:
4198       {
4199         m_VideoPlayerSubtitle->SendMessage(
4200             std::make_shared<CDVDMsgSubtitleClutChange>((uint8_t*)pData));
4201       }
4202       break;
4203     case DVDNAV_SPU_STREAM_CHANGE:
4204       {
4205         dvdnav_spu_stream_change_event_t* event = static_cast<dvdnav_spu_stream_change_event_t*>(pData);
4206
4207         int iStream = event->physical_wide;
4208         bool visible = !(iStream & 0x80);
4209
4210         SetSubtitleVisibleInternal(visible);
4211
4212         if (iStream >= 0)
4213           m_dvd.iSelectedSPUStream = (iStream & ~0x80);
4214         else
4215           m_dvd.iSelectedSPUStream = -1;
4216
4217         m_CurrentSubtitle.stream = NULL;
4218       }
4219       break;
4220     case DVDNAV_AUDIO_STREAM_CHANGE:
4221       {
4222         dvdnav_audio_stream_change_event_t* event = static_cast<dvdnav_audio_stream_change_event_t*>(pData);
4223         // Tell system what audiostream should be opened by default
4224         m_dvd.iSelectedAudioStream = event->physical;
4225         m_CurrentAudio.stream = NULL;
4226       }
4227       break;
4228     case DVDNAV_HIGHLIGHT:
4229       {
4230         //dvdnav_highlight_event_t* pInfo = (dvdnav_highlight_event_t*)pData;
4231         int iButton = pStream->GetCurrentButton();
4232         CLog::Log(LOGDEBUG, "DVDNAV_HIGHLIGHT: Highlight button {}", iButton);
4233         m_VideoPlayerSubtitle->UpdateOverlayInfo(std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream), LIBDVDNAV_BUTTON_NORMAL);
4234       }
4235       break;
4236     case DVDNAV_VTS_CHANGE:
4237       {
4238         //dvdnav_vts_change_event_t* vts_change_event = (dvdnav_vts_change_event_t*)pData;
4239         CLog::Log(LOGDEBUG, "DVDNAV_VTS_CHANGE");
4240
4241         //Make sure we clear all the old overlays here, or else old forced items are left.
4242         m_overlayContainer.Clear();
4243
4244         //Force an aspect ratio that is set in the dvdheaders if available
4245         m_CurrentVideo.hint.aspect = static_cast<double>(pStream->GetVideoAspectRatio());
4246         if( m_VideoPlayerVideo->IsInited() )
4247           m_VideoPlayerVideo->SendMessage(std::make_shared<CDVDMsgDouble>(
4248               CDVDMsg::VIDEO_SET_ASPECT, m_CurrentVideo.hint.aspect));
4249
4250         m_SelectionStreams.Clear(STREAM_NONE, STREAM_SOURCE_NAV);
4251         m_SelectionStreams.Update(m_pInputStream, m_pDemuxer.get());
4252         UpdateContent();
4253
4254         return NAVRESULT_HOLD;
4255       }
4256       break;
4257     case DVDNAV_CELL_CHANGE:
4258       {
4259         //dvdnav_cell_change_event_t* cell_change_event = (dvdnav_cell_change_event_t*)pData;
4260         CLog::Log(LOGDEBUG, "DVDNAV_CELL_CHANGE");
4261
4262         if (m_dvd.state != DVDSTATE_STILL)
4263           m_dvd.state = DVDSTATE_NORMAL;
4264       }
4265       break;
4266     case DVDNAV_NAV_PACKET:
4267       {
4268           //pci_t* pci = (pci_t*)pData;
4269
4270           // this should be possible to use to make sure we get
4271           // seamless transitions over these boundaries
4272           // if we remember the old vobunits boundaries
4273           // when a packet comes out of demuxer that has
4274           // pts values outside that boundary, it belongs
4275           // to the new vobunit, which has new timestamps
4276           UpdatePlayState(0);
4277       }
4278       break;
4279     case DVDNAV_HOP_CHANNEL:
4280       {
4281         // This event is issued whenever a non-seamless operation has been executed.
4282         // Applications with fifos should drop the fifos content to speed up responsiveness.
4283         CLog::Log(LOGDEBUG, "DVDNAV_HOP_CHANNEL");
4284         if(m_dvd.state == DVDSTATE_SEEK)
4285           m_dvd.state = DVDSTATE_NORMAL;
4286         else
4287         {
4288           bool sync = !IsInMenuInternal();
4289           FlushBuffers(DVD_NOPTS_VALUE, false, sync);
4290           m_dvd.syncClock = true;
4291           m_dvd.state = DVDSTATE_NORMAL;
4292           if (m_pDemuxer)
4293             m_pDemuxer->Flush();
4294         }
4295
4296         return NAVRESULT_ERROR;
4297       }
4298       break;
4299     case DVDNAV_STOP:
4300       {
4301         CLog::Log(LOGDEBUG, "DVDNAV_STOP");
4302         m_dvd.state = DVDSTATE_NORMAL;
4303       }
4304       break;
4305     case DVDNAV_ERROR:
4306       {
4307         CLog::Log(LOGDEBUG, "DVDNAV_ERROR");
4308         m_dvd.state = DVDSTATE_NORMAL;
4309         CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(16026),
4310                                               g_localizeStrings.Get(16029));
4311       }
4312       break;
4313     default:
4314     {}
4315       break;
4316     }
4317   }
4318   return NAVRESULT_NOP;
4319 }
4320
4321 void CVideoPlayer::GetVideoResolution(unsigned int &width, unsigned int &height)
4322 {
4323   RESOLUTION_INFO res = CServiceBroker::GetWinSystem()->GetGfxContext().GetResInfo();
4324   width = res.iWidth;
4325   height = res.iHeight;
4326 }
4327
4328 bool CVideoPlayer::OnAction(const CAction &action)
4329 {
4330 #define THREAD_ACTION(action) \
4331   do \
4332   { \
4333     if (!IsCurrentThread()) \
4334     { \
4335       m_messenger.Put( \
4336           std::make_shared<CDVDMsgType<CAction>>(CDVDMsg::GENERAL_GUI_ACTION, action)); \
4337       return true; \
4338     } \
4339   } while (false)
4340
4341   std::shared_ptr<CDVDInputStream::IMenus> pMenus = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream);
4342   if (pMenus)
4343   {
4344     if (m_dvd.state == DVDSTATE_STILL && m_dvd.iDVDStillTime != 0ms &&
4345         pMenus->GetTotalButtons() == 0)
4346     {
4347       switch(action.GetID())
4348       {
4349         case ACTION_NEXT_ITEM:
4350         case ACTION_MOVE_RIGHT:
4351         case ACTION_MOVE_UP:
4352         case ACTION_SELECT_ITEM:
4353           {
4354             THREAD_ACTION(action);
4355             /* this will force us out of the stillframe */
4356             CLog::Log(LOGDEBUG, "{} - User asked to exit stillframe", __FUNCTION__);
4357             m_dvd.iDVDStillStartTime = {};
4358             m_dvd.iDVDStillTime = 1ms;
4359           }
4360           return true;
4361       }
4362     }
4363
4364
4365     switch (action.GetID())
4366     {
4367 /* this code is disabled to allow switching playlist items (dvdimage "stacks") */
4368 #if 0
4369     case ACTION_PREV_ITEM:  // SKIP-:
4370       {
4371         THREAD_ACTION(action);
4372         CLog::Log(LOGDEBUG, " - pushed prev");
4373         pMenus->OnPrevious();
4374         m_processInfo->SeekFinished(0);
4375         return true;
4376       }
4377       break;
4378     case ACTION_NEXT_ITEM:  // SKIP+:
4379       {
4380         THREAD_ACTION(action);
4381         CLog::Log(LOGDEBUG, " - pushed next");
4382         pMenus->OnNext();
4383         m_processInfo->SeekFinished(0);
4384         return true;
4385       }
4386       break;
4387 #endif
4388     case ACTION_SHOW_VIDEOMENU:   // start button
4389       {
4390         THREAD_ACTION(action);
4391         CLog::LogF(LOGDEBUG, "Trying to go to the menu");
4392         if (pMenus->OnMenu())
4393         {
4394           if (m_playSpeed == DVD_PLAYSPEED_PAUSE)
4395           {
4396             SetPlaySpeed(DVD_PLAYSPEED_NORMAL);
4397             m_callback.OnPlayBackResumed();
4398           }
4399
4400           // send a message to everyone that we've gone to the menu
4401           CGUIMessage msg(GUI_MSG_VIDEO_MENU_STARTED, 0, 0);
4402           CServiceBroker::GetGUI()->GetWindowManager().SendThreadMessage(msg);
4403         }
4404         return true;
4405       }
4406       break;
4407     }
4408
4409     if (pMenus->IsInMenu())
4410     {
4411       switch (action.GetID())
4412       {
4413       case ACTION_NEXT_ITEM:
4414         THREAD_ACTION(action);
4415         CLog::Log(LOGDEBUG, " - pushed next in menu, stream will decide");
4416         if (pMenus->CanSeek() && GetChapterCount() > 0 && GetChapter() < GetChapterCount())
4417           m_messenger.Put(std::make_shared<CDVDMsgPlayerSeekChapter>(GetChapter() + 1));
4418         else
4419           pMenus->OnNext();
4420
4421         m_processInfo->SeekFinished(0);
4422         return true;
4423       case ACTION_PREV_ITEM:
4424         THREAD_ACTION(action);
4425         CLog::Log(LOGDEBUG, " - pushed prev in menu, stream will decide");
4426         if (pMenus->CanSeek() && GetChapterCount() > 0 && GetChapter() > 0)
4427           m_messenger.Put(std::make_shared<CDVDMsgPlayerSeekChapter>(GetPreviousChapter()));
4428         else
4429           pMenus->OnPrevious();
4430
4431         m_processInfo->SeekFinished(0);
4432         return true;
4433       case ACTION_PREVIOUS_MENU:
4434       case ACTION_NAV_BACK:
4435         {
4436           THREAD_ACTION(action);
4437           CLog::Log(LOGDEBUG, " - menu back");
4438           pMenus->OnBack();
4439         }
4440         break;
4441       case ACTION_MOVE_LEFT:
4442         {
4443           THREAD_ACTION(action);
4444           CLog::Log(LOGDEBUG, " - move left");
4445           pMenus->OnLeft();
4446         }
4447         break;
4448       case ACTION_MOVE_RIGHT:
4449         {
4450           THREAD_ACTION(action);
4451           CLog::Log(LOGDEBUG, " - move right");
4452           pMenus->OnRight();
4453         }
4454         break;
4455       case ACTION_MOVE_UP:
4456         {
4457           THREAD_ACTION(action);
4458           CLog::Log(LOGDEBUG, " - move up");
4459           pMenus->OnUp();
4460         }
4461         break;
4462       case ACTION_MOVE_DOWN:
4463         {
4464           THREAD_ACTION(action);
4465           CLog::Log(LOGDEBUG, " - move down");
4466           pMenus->OnDown();
4467         }
4468         break;
4469
4470       case ACTION_MOUSE_MOVE:
4471       case ACTION_MOUSE_LEFT_CLICK:
4472         {
4473           CRect rs, rd, rv;
4474           m_renderManager.GetVideoRect(rs, rd, rv);
4475           CPoint pt(action.GetAmount(), action.GetAmount(1));
4476           if (!rd.PtInRect(pt))
4477             return false; // out of bounds
4478           THREAD_ACTION(action);
4479           // convert to video coords...
4480           pt -= CPoint(rd.x1, rd.y1);
4481           pt.x *= rs.Width() / rd.Width();
4482           pt.y *= rs.Height() / rd.Height();
4483           pt += CPoint(rs.x1, rs.y1);
4484           if (action.GetID() == ACTION_MOUSE_LEFT_CLICK)
4485           {
4486             if (pMenus->OnMouseClick(pt))
4487               return true;
4488             else
4489             {
4490               CServiceBroker::GetAppMessenger()->PostMsg(
4491                   TMSG_GUI_ACTION, WINDOW_INVALID, -1,
4492                   static_cast<void*>(new CAction(ACTION_TRIGGER_OSD)));
4493               return false;
4494             }
4495           }
4496           return pMenus->OnMouseMove(pt);
4497         }
4498         break;
4499       case ACTION_SELECT_ITEM:
4500         {
4501           THREAD_ACTION(action);
4502           CLog::Log(LOGDEBUG, " - button select");
4503           // show button pushed overlay
4504           if(m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD))
4505             m_VideoPlayerSubtitle->UpdateOverlayInfo(std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream), LIBDVDNAV_BUTTON_CLICKED);
4506
4507           pMenus->ActivateButton();
4508         }
4509         break;
4510       case REMOTE_0:
4511       case REMOTE_1:
4512       case REMOTE_2:
4513       case REMOTE_3:
4514       case REMOTE_4:
4515       case REMOTE_5:
4516       case REMOTE_6:
4517       case REMOTE_7:
4518       case REMOTE_8:
4519       case REMOTE_9:
4520         {
4521           THREAD_ACTION(action);
4522           // Offset from key codes back to button number
4523           int button = action.GetID() - REMOTE_0;
4524           CLog::Log(LOGDEBUG, " - button pressed {}", button);
4525           pMenus->SelectButton(button);
4526         }
4527        break;
4528       default:
4529         return false;
4530         break;
4531       }
4532       return true; // message is handled
4533     }
4534   }
4535
4536   pMenus.reset();
4537
4538   switch (action.GetID())
4539   {
4540     case ACTION_NEXT_ITEM:
4541       if (GetChapter() > 0 && GetChapter() < GetChapterCount())
4542       {
4543         m_messenger.Put(std::make_shared<CDVDMsgPlayerSeekChapter>(GetChapter() + 1));
4544         m_processInfo->SeekFinished(0);
4545         return true;
4546       }
4547       else if (SeekScene(Direction::FORWARD))
4548         return true;
4549       else
4550         break;
4551     case ACTION_PREV_ITEM:
4552       if (GetChapter() > 0)
4553       {
4554         m_messenger.Put(std::make_shared<CDVDMsgPlayerSeekChapter>(GetPreviousChapter()));
4555         m_processInfo->SeekFinished(0);
4556         return true;
4557       }
4558       else if (SeekScene(Direction::BACKWARD))
4559         return true;
4560       else
4561         break;
4562     case ACTION_TOGGLE_COMMSKIP:
4563       m_SkipCommercials = !m_SkipCommercials;
4564       CGUIDialogKaiToast::QueueNotification(g_localizeStrings.Get(25011),
4565                                             g_localizeStrings.Get(m_SkipCommercials ? 25013 : 25012));
4566       break;
4567     case ACTION_PLAYER_DEBUG:
4568       m_renderManager.ToggleDebug();
4569       break;
4570     case ACTION_PLAYER_DEBUG_VIDEO:
4571       m_renderManager.ToggleDebugVideo();
4572       break;
4573
4574     case ACTION_PLAYER_PROCESS_INFO:
4575       if (CServiceBroker::GetGUI()->GetWindowManager().GetActiveWindow() != WINDOW_DIALOG_PLAYER_PROCESS_INFO)
4576       {
4577         CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_DIALOG_PLAYER_PROCESS_INFO);
4578         return true;
4579       }
4580       break;
4581   }
4582
4583   // return false to inform the caller we didn't handle the message
4584   return false;
4585 }
4586
4587 bool CVideoPlayer::IsInMenuInternal() const
4588 {
4589   std::shared_ptr<CDVDInputStream::IMenus> pStream = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream);
4590   if (pStream)
4591   {
4592     if (m_dvd.state == DVDSTATE_STILL)
4593       return true;
4594     else
4595       return pStream->IsInMenu();
4596   }
4597   return false;
4598 }
4599
4600
4601 bool CVideoPlayer::IsInMenu() const
4602 {
4603   std::unique_lock<CCriticalSection> lock(m_StateSection);
4604   return m_State.isInMenu;
4605 }
4606
4607 MenuType CVideoPlayer::GetSupportedMenuType() const
4608 {
4609   std::unique_lock<CCriticalSection> lock(m_StateSection);
4610   return m_State.menuType;
4611 }
4612
4613 std::string CVideoPlayer::GetPlayerState()
4614 {
4615   std::unique_lock<CCriticalSection> lock(m_StateSection);
4616   return m_State.player_state;
4617 }
4618
4619 bool CVideoPlayer::SetPlayerState(const std::string& state)
4620 {
4621   m_messenger.Put(std::make_shared<CDVDMsgPlayerSetState>(state));
4622   return true;
4623 }
4624
4625 int CVideoPlayer::GetChapterCount() const
4626 {
4627   std::unique_lock<CCriticalSection> lock(m_StateSection);
4628   return m_State.chapters.size();
4629 }
4630
4631 int CVideoPlayer::GetChapter() const
4632 {
4633   std::unique_lock<CCriticalSection> lock(m_StateSection);
4634   return m_State.chapter;
4635 }
4636
4637 void CVideoPlayer::GetChapterName(std::string& strChapterName, int chapterIdx) const
4638 {
4639   std::unique_lock<CCriticalSection> lock(m_StateSection);
4640   if (chapterIdx == -1 && m_State.chapter > 0 && m_State.chapter <= (int) m_State.chapters.size())
4641     strChapterName = m_State.chapters[m_State.chapter - 1].first;
4642   else if (chapterIdx > 0 && chapterIdx <= (int) m_State.chapters.size())
4643     strChapterName = m_State.chapters[chapterIdx - 1].first;
4644 }
4645
4646 int CVideoPlayer::SeekChapter(int iChapter)
4647 {
4648   if (GetChapter() > 0)
4649   {
4650     if (iChapter < 0)
4651       iChapter = 0;
4652     if (iChapter > GetChapterCount())
4653       return 0;
4654
4655     // Seek to the chapter.
4656     m_messenger.Put(std::make_shared<CDVDMsgPlayerSeekChapter>(iChapter));
4657     SynchronizeDemuxer();
4658   }
4659
4660   return 0;
4661 }
4662
4663 int64_t CVideoPlayer::GetChapterPos(int chapterIdx) const
4664 {
4665   std::unique_lock<CCriticalSection> lock(m_StateSection);
4666   if (chapterIdx > 0 && chapterIdx <= (int) m_State.chapters.size())
4667     return m_State.chapters[chapterIdx - 1].second;
4668
4669   return -1;
4670 }
4671
4672 int CVideoPlayer::GetPreviousChapter()
4673 {
4674   // 5-second grace period from chapter start to skip backwards to previous chapter
4675   // Afterwards skip to start of current chapter.
4676   const int chapter = GetChapter();
4677
4678   if (chapter > 0 && (GetTime() < (GetChapterPos(chapter) + 5) * 1000))
4679     return chapter - 1;
4680   else
4681     return chapter;
4682 }
4683
4684 void CVideoPlayer::AddSubtitle(const std::string& strSubPath)
4685 {
4686   m_messenger.Put(
4687       std::make_shared<CDVDMsgType<std::string>>(CDVDMsg::SUBTITLE_ADDFILE, strSubPath));
4688 }
4689
4690 bool CVideoPlayer::IsCaching() const
4691 {
4692   std::unique_lock<CCriticalSection> lock(m_StateSection);
4693   return !m_State.isInMenu && m_State.caching;
4694 }
4695
4696 int CVideoPlayer::GetCacheLevel() const
4697 {
4698   std::unique_lock<CCriticalSection> lock(m_StateSection);
4699   return (int)(m_State.cache_level * 100);
4700 }
4701
4702 double CVideoPlayer::GetQueueTime()
4703 {
4704   int a = m_VideoPlayerAudio->GetLevel();
4705   int v = m_processInfo->GetLevelVQ();
4706   return std::max(a, v) * m_messageQueueTimeSize * 1000.0 / 100.0;
4707 }
4708
4709 int CVideoPlayer::AddSubtitleFile(const std::string& filename, const std::string& subfilename)
4710 {
4711   std::string ext = URIUtils::GetExtension(filename);
4712   std::string vobsubfile = subfilename;
4713   if (ext == ".idx" || ext == ".sup")
4714   {
4715     std::shared_ptr<CDVDDemux> pDemux;
4716     if (ext == ".idx")
4717     {
4718       if (vobsubfile.empty())
4719       {
4720         // find corresponding .sub (e.g. in case of manually selected .idx sub)
4721         vobsubfile = CUtil::GetVobSubSubFromIdx(filename);
4722         if (vobsubfile.empty())
4723           return -1;
4724       }
4725
4726       auto pDemuxVobsub = std::make_shared<CDVDDemuxVobsub>();
4727       if (!pDemuxVobsub->Open(filename, STREAM_SOURCE_NONE, vobsubfile))
4728         return -1;
4729
4730       m_SelectionStreams.Update(nullptr, pDemuxVobsub.get(), vobsubfile);
4731       pDemux = pDemuxVobsub;
4732     }
4733     else // .sup file
4734     {
4735       CFileItem item(filename, false);
4736       std::shared_ptr<CDVDInputStream> pInput;
4737       pInput = CDVDFactoryInputStream::CreateInputStream(nullptr, item);
4738       if (!pInput || !pInput->Open())
4739         return -1;
4740
4741       auto pDemuxFFmpeg = std::make_shared<CDVDDemuxFFmpeg>();
4742       if (!pDemuxFFmpeg->Open(pInput, false))
4743         return -1;
4744
4745       m_SelectionStreams.Update(nullptr, pDemuxFFmpeg.get(), filename);
4746       pDemux = pDemuxFFmpeg;
4747     }
4748
4749     ExternalStreamInfo info =
4750         CUtil::GetExternalStreamDetailsFromFilename(m_item.GetDynPath(), filename);
4751
4752     for (auto sub : pDemux->GetStreams())
4753     {
4754       if (sub->type != STREAM_SUBTITLE)
4755         continue;
4756
4757       int index = m_SelectionStreams.TypeIndexOf(STREAM_SUBTITLE,
4758         m_SelectionStreams.Source(STREAM_SOURCE_DEMUX_SUB, filename),
4759         sub->demuxerId, sub->uniqueId);
4760       SelectionStream& stream = m_SelectionStreams.Get(STREAM_SUBTITLE, index);
4761
4762       if (stream.name.empty())
4763         stream.name = info.name;
4764
4765       if (stream.language.empty())
4766         stream.language = info.language;
4767
4768       if (static_cast<StreamFlags>(info.flag) != StreamFlags::FLAG_NONE)
4769         stream.flags = static_cast<StreamFlags>(info.flag);
4770     }
4771
4772     UpdateContent();
4773     // the demuxer id is unique
4774     m_subtitleDemuxerMap[pDemux->GetDemuxerId()] = pDemux;
4775     return m_SelectionStreams.TypeIndexOf(
4776         STREAM_SUBTITLE, m_SelectionStreams.Source(STREAM_SOURCE_DEMUX_SUB, filename),
4777         pDemux->GetDemuxerId(), 0);
4778   }
4779
4780   if(ext == ".sub")
4781   {
4782     // if this looks like vobsub file (i.e. .idx found), add it as such
4783     std::string vobsubidx = CUtil::GetVobSubIdxFromSub(filename);
4784     if (!vobsubidx.empty())
4785       return AddSubtitleFile(vobsubidx, filename);
4786   }
4787
4788   SelectionStream s;
4789   s.source   = m_SelectionStreams.Source(STREAM_SOURCE_TEXT, filename);
4790   s.type     = STREAM_SUBTITLE;
4791   s.id       = 0;
4792   s.filename = filename;
4793   ExternalStreamInfo info = CUtil::GetExternalStreamDetailsFromFilename(m_item.GetDynPath(), filename);
4794   s.name = info.name;
4795   s.language = info.language;
4796   if (static_cast<StreamFlags>(info.flag) != StreamFlags::FLAG_NONE)
4797     s.flags = static_cast<StreamFlags>(info.flag);
4798
4799   m_SelectionStreams.Update(s);
4800   UpdateContent();
4801   return m_SelectionStreams.TypeIndexOf(STREAM_SUBTITLE, s.source, s.demuxerId, s.id);
4802 }
4803
4804 void CVideoPlayer::UpdatePlayState(double timeout)
4805 {
4806   if (m_State.timestamp != 0 &&
4807       m_State.timestamp + DVD_MSEC_TO_TIME(timeout) > m_clock.GetAbsoluteClock())
4808     return;
4809
4810   SPlayerState state(m_State);
4811
4812   state.dts = DVD_NOPTS_VALUE;
4813   if (m_CurrentVideo.dts != DVD_NOPTS_VALUE)
4814     state.dts = m_CurrentVideo.dts;
4815   else if (m_CurrentAudio.dts != DVD_NOPTS_VALUE)
4816     state.dts = m_CurrentAudio.dts;
4817   else if (m_CurrentVideo.startpts != DVD_NOPTS_VALUE)
4818     state.dts = m_CurrentVideo.startpts;
4819   else if (m_CurrentAudio.startpts != DVD_NOPTS_VALUE)
4820     state.dts = m_CurrentAudio.startpts;
4821
4822   state.startTime = 0;
4823   state.timeMin = 0;
4824
4825   std::shared_ptr<CDVDInputStream::IMenus> pMenu = std::dynamic_pointer_cast<CDVDInputStream::IMenus>(m_pInputStream);
4826
4827   if (m_pDemuxer)
4828   {
4829     if (IsInMenuInternal() && pMenu && !pMenu->CanSeek())
4830       state.chapter = 0;
4831     else
4832       state.chapter = m_pDemuxer->GetChapter();
4833
4834     state.chapters.clear();
4835     if (m_pDemuxer->GetChapterCount() > 0)
4836     {
4837       for (int i = 0, ie = m_pDemuxer->GetChapterCount(); i < ie; ++i)
4838       {
4839         std::string name;
4840         m_pDemuxer->GetChapterName(name, i + 1);
4841         state.chapters.emplace_back(name, m_pDemuxer->GetChapterPos(i + 1));
4842       }
4843     }
4844     CServiceBroker::GetDataCacheCore().SetChapters(state.chapters);
4845
4846     state.time = m_clock.GetClock(false) * 1000 / DVD_TIME_BASE;
4847     state.timeMax = m_pDemuxer->GetStreamLength();
4848   }
4849
4850   state.canpause = false;
4851   state.canseek = false;
4852   state.cantempo = false;
4853   state.isInMenu = false;
4854   state.menuType = MenuType::NONE;
4855
4856   if (m_pInputStream)
4857   {
4858     CDVDInputStream::IChapter* pChapter = m_pInputStream->GetIChapter();
4859     if (pChapter)
4860     {
4861       if (IsInMenuInternal() && pMenu && !pMenu->CanSeek())
4862         state.chapter = 0;
4863       else
4864         state.chapter = pChapter->GetChapter();
4865
4866       state.chapters.clear();
4867       if (pChapter->GetChapterCount() > 0)
4868       {
4869         for (int i = 0, ie = pChapter->GetChapterCount(); i < ie; ++i)
4870         {
4871           std::string name;
4872           pChapter->GetChapterName(name, i + 1);
4873           state.chapters.emplace_back(name, pChapter->GetChapterPos(i + 1));
4874         }
4875       }
4876       CServiceBroker::GetDataCacheCore().SetChapters(state.chapters);
4877     }
4878
4879     CDVDInputStream::ITimes* pTimes = m_pInputStream->GetITimes();
4880     CDVDInputStream::IDisplayTime* pDisplayTime = m_pInputStream->GetIDisplayTime();
4881
4882     CDVDInputStream::ITimes::Times times;
4883     if (pTimes && pTimes->GetTimes(times))
4884     {
4885       state.startTime = times.startTime;
4886       state.time = (m_clock.GetClock(false) - times.ptsStart) * 1000 / DVD_TIME_BASE;
4887       state.timeMax = (times.ptsEnd - times.ptsStart) * 1000 / DVD_TIME_BASE;
4888       state.timeMin = (times.ptsBegin - times.ptsStart) * 1000 / DVD_TIME_BASE;
4889       state.time_offset = -times.ptsStart;
4890     }
4891     else if (pDisplayTime && pDisplayTime->GetTotalTime() > 0)
4892     {
4893       if (state.dts != DVD_NOPTS_VALUE)
4894       {
4895         int dispTime = 0;
4896         if (m_CurrentVideo.id >= 0 && m_CurrentVideo.dispTime)
4897           dispTime = m_CurrentVideo.dispTime;
4898         else if (m_CurrentAudio.dispTime)
4899           dispTime = m_CurrentAudio.dispTime;
4900
4901         state.time_offset = DVD_MSEC_TO_TIME(dispTime) - state.dts;
4902       }
4903       state.time += state.time_offset * 1000 / DVD_TIME_BASE;
4904       state.timeMax = pDisplayTime->GetTotalTime();
4905     }
4906     else
4907     {
4908       state.time_offset = 0;
4909     }
4910
4911     if (pMenu)
4912     {
4913       if (!pMenu->GetState(state.player_state))
4914         state.player_state = "";
4915
4916       if (m_dvd.state == DVDSTATE_STILL)
4917       {
4918         const auto now = std::chrono::steady_clock::now();
4919         const auto duration =
4920             std::chrono::duration_cast<std::chrono::milliseconds>(now - m_dvd.iDVDStillStartTime);
4921         state.time = duration.count();
4922         state.timeMax = m_dvd.iDVDStillTime.count();
4923         state.isInMenu = true;
4924       }
4925       else if (IsInMenuInternal())
4926       {
4927         state.time = pDisplayTime->GetTime();
4928         state.isInMenu = true;
4929         if (!pMenu->CanSeek())
4930           state.time_offset = 0;
4931       }
4932       state.menuType = pMenu->GetSupportedMenuType();
4933     }
4934
4935     state.canpause = m_pInputStream->CanPause();
4936
4937     bool realtime = m_pInputStream->IsRealtime();
4938
4939     if (CServiceBroker::GetSettingsComponent()->GetSettings()->GetBool(CSettings::SETTING_VIDEOPLAYER_USEDISPLAYASCLOCK) &&
4940         !realtime)
4941     {
4942       state.cantempo = true;
4943     }
4944     else
4945     {
4946       state.cantempo = false;
4947     }
4948
4949     m_processInfo->SetStateRealtime(realtime);
4950   }
4951
4952   if (m_Edl.HasCuts())
4953   {
4954     state.time = static_cast<double>(
4955         m_Edl.GetTimeWithoutCuts(std::chrono::milliseconds(std::lround(state.time))).count());
4956     state.timeMax = state.timeMax - static_cast<double>(m_Edl.GetTotalCutTime().count());
4957   }
4958
4959   if (m_caching > CACHESTATE_DONE && m_caching < CACHESTATE_PLAY)
4960     state.caching = true;
4961   else
4962     state.caching = false;
4963
4964   double queueTime = GetQueueTime();
4965   CacheInfo cache = GetCachingTimes();
4966
4967   if (cache.valid)
4968   {
4969     state.cache_level = std::max(0.0, std::min(1.0, cache.level));
4970     state.cache_offset = cache.offset;
4971     state.cache_time = cache.time;
4972   }
4973   else
4974   {
4975     state.cache_level = std::min(1.0, queueTime / (m_messageQueueTimeSize * 1000.0));
4976     state.cache_offset = queueTime / state.timeMax;
4977     state.cache_time = queueTime / 1000.0;
4978   }
4979
4980   XFILE::SCacheStatus status;
4981   if (m_pInputStream && m_pInputStream->GetCacheStatus(&status))
4982   {
4983     state.cache_bytes = status.forward;
4984     if(state.timeMax)
4985       state.cache_bytes += m_pInputStream->GetLength() * (int64_t)(queueTime / state.timeMax);
4986   }
4987   else
4988     state.cache_bytes = 0;
4989
4990   state.timestamp = m_clock.GetAbsoluteClock();
4991
4992   if (state.timeMax <= 0)
4993   {
4994     state.timeMax = state.time;
4995     state.timeMin = state.time;
4996   }
4997   if (state.timeMin == state.timeMax)
4998   {
4999     state.canseek = false;
5000     state.cantempo = false;
5001   }
5002   else
5003   {
5004     state.canseek = true;
5005     state.canpause = true;
5006   }
5007
5008   m_processInfo->SetPlayTimes(state.startTime, state.time, state.timeMin, state.timeMax);
5009
5010   std::unique_lock<CCriticalSection> lock(m_StateSection);
5011   m_State = state;
5012 }
5013
5014 int64_t CVideoPlayer::GetUpdatedTime()
5015 {
5016   UpdatePlayState(0);
5017   return llrint(m_State.time);
5018 }
5019
5020 void CVideoPlayer::SetDynamicRangeCompression(long drc)
5021 {
5022   m_processInfo->GetVideoSettingsLocked().SetVolumeAmplification(static_cast<float>(drc) / 100);
5023   m_VideoPlayerAudio->SetDynamicRangeCompression(drc);
5024 }
5025
5026 CVideoSettings CVideoPlayer::GetVideoSettings() const
5027 {
5028   return m_processInfo->GetVideoSettings();
5029 }
5030
5031 void CVideoPlayer::SetVideoSettings(CVideoSettings& settings)
5032 {
5033   m_processInfo->SetVideoSettings(settings);
5034   m_renderManager.SetVideoSettings(settings);
5035   m_renderManager.SetDelay(static_cast<int>(settings.m_AudioDelay * 1000.0f));
5036   m_renderManager.SetSubtitleVerticalPosition(settings.m_subtitleVerticalPosition,
5037                                               settings.m_subtitleVerticalPositionSave);
5038   m_VideoPlayerVideo->EnableSubtitle(settings.m_SubtitleOn);
5039   m_VideoPlayerVideo->SetSubtitleDelay(static_cast<int>(-settings.m_SubtitleDelay * DVD_TIME_BASE));
5040 }
5041
5042 void CVideoPlayer::FrameMove()
5043 {
5044   m_renderManager.FrameMove();
5045 }
5046
5047 void CVideoPlayer::Render(bool clear, uint32_t alpha, bool gui)
5048 {
5049   m_renderManager.Render(clear, 0, alpha, gui);
5050 }
5051
5052 void CVideoPlayer::FlushRenderer()
5053 {
5054   m_renderManager.Flush(true, true);
5055 }
5056
5057 void CVideoPlayer::SetRenderViewMode(int mode, float zoom, float par, float shift, bool stretch)
5058 {
5059   m_processInfo->GetVideoSettingsLocked().SetViewMode(mode, zoom, par, shift, stretch);
5060   m_renderManager.SetVideoSettings(m_processInfo->GetVideoSettings());
5061   m_renderManager.SetViewMode(mode);
5062 }
5063
5064 float CVideoPlayer::GetRenderAspectRatio() const
5065 {
5066   return m_renderManager.GetAspectRatio();
5067 }
5068
5069 void CVideoPlayer::GetRects(CRect& source, CRect& dest, CRect& view) const
5070 {
5071   m_renderManager.GetVideoRect(source, dest, view);
5072 }
5073
5074 unsigned int CVideoPlayer::GetOrientation() const
5075 {
5076   return m_renderManager.GetOrientation();
5077 }
5078
5079 void CVideoPlayer::TriggerUpdateResolution()
5080 {
5081   std::string stereomode;
5082   m_renderManager.TriggerUpdateResolution(0, 0, 0, stereomode);
5083 }
5084
5085 bool CVideoPlayer::IsRenderingVideo() const
5086 {
5087   return m_renderManager.IsConfigured();
5088 }
5089
5090 bool CVideoPlayer::Supports(EINTERLACEMETHOD method) const
5091 {
5092   if (!m_processInfo)
5093     return false;
5094   return m_processInfo->Supports(method);
5095 }
5096
5097 EINTERLACEMETHOD CVideoPlayer::GetDeinterlacingMethodDefault() const
5098 {
5099   if (!m_processInfo)
5100     return EINTERLACEMETHOD::VS_INTERLACEMETHOD_NONE;
5101   return m_processInfo->GetDeinterlacingMethodDefault();
5102 }
5103
5104 bool CVideoPlayer::Supports(ESCALINGMETHOD method) const
5105 {
5106   return m_renderManager.Supports(method);
5107 }
5108
5109 bool CVideoPlayer::Supports(ERENDERFEATURE feature) const
5110 {
5111   return m_renderManager.Supports(feature);
5112 }
5113
5114 unsigned int CVideoPlayer::RenderCaptureAlloc()
5115 {
5116   return m_renderManager.AllocRenderCapture();
5117 }
5118
5119 void CVideoPlayer::RenderCapture(unsigned int captureId, unsigned int width, unsigned int height, int flags)
5120 {
5121   m_renderManager.StartRenderCapture(captureId, width, height, flags);
5122 }
5123
5124 void CVideoPlayer::RenderCaptureRelease(unsigned int captureId)
5125 {
5126   m_renderManager.ReleaseRenderCapture(captureId);
5127 }
5128
5129 bool CVideoPlayer::RenderCaptureGetPixels(unsigned int captureId, unsigned int millis, uint8_t *buffer, unsigned int size)
5130 {
5131   return m_renderManager.RenderCaptureGetPixels(captureId, millis, buffer, size);
5132 }
5133
5134 void CVideoPlayer::VideoParamsChange()
5135 {
5136   m_messenger.Put(std::make_shared<CDVDMsg>(CDVDMsg::PLAYER_AVCHANGE));
5137 }
5138
5139 void CVideoPlayer::GetDebugInfo(std::string &audio, std::string &video, std::string &general)
5140 {
5141   audio = m_VideoPlayerAudio->GetPlayerInfo();
5142   video = m_VideoPlayerVideo->GetPlayerInfo();
5143   GetGeneralInfo(general);
5144 }
5145
5146 void CVideoPlayer::UpdateClockSync(bool enabled)
5147 {
5148   m_processInfo->SetRenderClockSync(enabled);
5149 }
5150
5151 void CVideoPlayer::UpdateRenderInfo(CRenderInfo &info)
5152 {
5153   m_processInfo->UpdateRenderInfo(info);
5154 }
5155
5156 void CVideoPlayer::UpdateRenderBuffers(int queued, int discard, int free)
5157 {
5158   m_processInfo->UpdateRenderBuffers(queued, discard, free);
5159 }
5160
5161 void CVideoPlayer::UpdateGuiRender(bool gui)
5162 {
5163   m_processInfo->SetGuiRender(gui);
5164 }
5165
5166 void CVideoPlayer::UpdateVideoRender(bool video)
5167 {
5168   m_processInfo->SetVideoRender(video);
5169 }
5170
5171 // IDispResource interface
5172 void CVideoPlayer::OnLostDisplay()
5173 {
5174   CLog::Log(LOGINFO, "VideoPlayer: OnLostDisplay received");
5175   m_VideoPlayerAudio->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, true), 1);
5176   m_VideoPlayerVideo->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, true), 1);
5177   m_clock.Pause(true);
5178   m_displayLost = true;
5179   FlushRenderer();
5180 }
5181
5182 void CVideoPlayer::OnResetDisplay()
5183 {
5184   if (!m_displayLost)
5185     return;
5186
5187   CLog::Log(LOGINFO, "VideoPlayer: OnResetDisplay received");
5188   m_VideoPlayerAudio->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, false), 1);
5189   m_VideoPlayerVideo->SendMessage(std::make_shared<CDVDMsgBool>(CDVDMsg::GENERAL_PAUSE, false), 1);
5190   m_clock.Pause(false);
5191   m_displayLost = false;
5192   m_VideoPlayerAudio->SendMessage(std::make_shared<CDVDMsg>(CDVDMsg::PLAYER_DISPLAY_RESET), 1);
5193 }
5194
5195 void CVideoPlayer::UpdateFileItemStreamDetails(CFileItem& item)
5196 {
5197   if (!m_UpdateStreamDetails)
5198     return;
5199   m_UpdateStreamDetails = false;
5200
5201   CLog::Log(LOGDEBUG, "CVideoPlayer: updating file item stream details with available streams");
5202
5203   VideoStreamInfo videoInfo;
5204   AudioStreamInfo audioInfo;
5205   SubtitleStreamInfo subtitleInfo;
5206   CVideoInfoTag* info = item.GetVideoInfoTag();
5207   GetVideoStreamInfo(CURRENT_STREAM, videoInfo);
5208   info->m_streamDetails.SetStreams(videoInfo, m_processInfo->GetMaxTime() / 1000, audioInfo,
5209                                    subtitleInfo);
5210
5211   //grab all the audio and subtitle info and save it
5212
5213   for (int i = 0; i < GetAudioStreamCount(); i++)
5214   {
5215     GetAudioStreamInfo(i, audioInfo);
5216     info->m_streamDetails.AddStream(new CStreamDetailAudio(audioInfo));
5217   }
5218
5219   for (int i = 0; i < GetSubtitleCount(); i++)
5220   {
5221     GetSubtitleStreamInfo(i, subtitleInfo);
5222     info->m_streamDetails.AddStream(new CStreamDetailSubtitle(subtitleInfo));
5223   }
5224 }
5225
5226 //------------------------------------------------------------------------------
5227 // content related methods
5228 //------------------------------------------------------------------------------
5229
5230 void CVideoPlayer::UpdateContent()
5231 {
5232   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5233   m_content.m_selectionStreams = m_SelectionStreams;
5234   m_content.m_programs = m_programs;
5235 }
5236
5237 void CVideoPlayer::UpdateContentState()
5238 {
5239   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5240
5241   m_content.m_videoIndex = m_SelectionStreams.TypeIndexOf(STREAM_VIDEO, m_CurrentVideo.source,
5242                                                       m_CurrentVideo.demuxerId, m_CurrentVideo.id);
5243   m_content.m_audioIndex = m_SelectionStreams.TypeIndexOf(STREAM_AUDIO, m_CurrentAudio.source,
5244                                                       m_CurrentAudio.demuxerId, m_CurrentAudio.id);
5245   m_content.m_subtitleIndex = m_SelectionStreams.TypeIndexOf(STREAM_SUBTITLE, m_CurrentSubtitle.source,
5246                                                          m_CurrentSubtitle.demuxerId, m_CurrentSubtitle.id);
5247
5248   if (m_pInputStream->IsStreamType(DVDSTREAM_TYPE_DVD) && m_content.m_videoIndex == -1 &&
5249       m_content.m_audioIndex == -1)
5250   {
5251     std::shared_ptr<CDVDInputStreamNavigator> nav =
5252           std::static_pointer_cast<CDVDInputStreamNavigator>(m_pInputStream);
5253
5254     m_content.m_videoIndex = m_SelectionStreams.TypeIndexOf(STREAM_VIDEO, STREAM_SOURCE_NAV, -1,
5255                                                             nav->GetActiveAngle());
5256     m_content.m_audioIndex = m_SelectionStreams.TypeIndexOf(STREAM_AUDIO, STREAM_SOURCE_NAV, -1,
5257                                                             nav->GetActiveAudioStream());
5258
5259     // only update the subtitle index in libdvdnav if the subtitle is provided by the dvd itself,
5260     // i.e. for external subtitles the index is always greater than the subtitlecount in dvdnav
5261     if (m_content.m_subtitleIndex < nav->GetSubTitleStreamCount())
5262     {
5263       m_content.m_subtitleIndex = m_SelectionStreams.TypeIndexOf(
5264           STREAM_SUBTITLE, STREAM_SOURCE_NAV, -1, nav->GetActiveSubtitleStream());
5265     }
5266   }
5267 }
5268
5269 void CVideoPlayer::GetVideoStreamInfo(int streamId, VideoStreamInfo& info) const
5270 {
5271   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5272
5273   if (streamId == CURRENT_STREAM)
5274     streamId = m_content.m_videoIndex;
5275
5276   if (streamId < 0 || streamId > GetVideoStreamCount() - 1)
5277   {
5278     info.valid = false;
5279     return;
5280   }
5281
5282   const SelectionStream& s = m_content.m_selectionStreams.Get(STREAM_VIDEO, streamId);
5283   if (s.language.length() > 0)
5284     info.language = s.language;
5285
5286   if (s.name.length() > 0)
5287     info.name = s.name;
5288
5289   m_renderManager.GetVideoRect(info.SrcRect, info.DestRect, info.VideoRect);
5290
5291   info.valid = true;
5292   info.bitrate = s.bitrate;
5293   info.width = s.width;
5294   info.height = s.height;
5295   info.codecName = s.codec;
5296   info.videoAspectRatio = s.aspect_ratio;
5297   info.stereoMode = s.stereo_mode;
5298   info.flags = s.flags;
5299   info.hdrType = s.hdrType;
5300 }
5301
5302 int CVideoPlayer::GetVideoStreamCount() const
5303 {
5304   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5305   return m_content.m_selectionStreams.CountType(STREAM_VIDEO);
5306 }
5307
5308 int CVideoPlayer::GetVideoStream() const
5309 {
5310   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5311   return m_content.m_videoIndex;
5312 }
5313
5314 void CVideoPlayer::SetVideoStream(int iStream)
5315 {
5316   m_messenger.Put(std::make_shared<CDVDMsgPlayerSetVideoStream>(iStream));
5317   m_processInfo->GetVideoSettingsLocked().SetVideoStream(iStream);
5318   SynchronizeDemuxer();
5319 }
5320
5321 void CVideoPlayer::GetAudioStreamInfo(int index, AudioStreamInfo& info) const
5322 {
5323   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5324
5325   if (index == CURRENT_STREAM)
5326     index = m_content.m_audioIndex;
5327
5328   if (index < 0 || index > GetAudioStreamCount() - 1)
5329   {
5330     info.valid = false;
5331     return;
5332   }
5333
5334   const SelectionStream& s = m_content.m_selectionStreams.Get(STREAM_AUDIO, index);
5335   info.language = s.language;
5336   info.name = s.name;
5337
5338   if (s.type == STREAM_NONE)
5339     info.name += " (Invalid)";
5340
5341   info.valid = true;
5342   info.bitrate = s.bitrate;
5343   info.channels = s.channels;
5344   info.codecName = s.codec;
5345   info.flags = s.flags;
5346 }
5347
5348 int CVideoPlayer::GetAudioStreamCount() const
5349 {
5350   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5351   return m_content.m_selectionStreams.CountType(STREAM_AUDIO);
5352 }
5353
5354 int CVideoPlayer::GetAudioStream()
5355 {
5356   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5357   return m_content.m_audioIndex;
5358 }
5359
5360 void CVideoPlayer::SetAudioStream(int iStream)
5361 {
5362   m_messenger.Put(std::make_shared<CDVDMsgPlayerSetAudioStream>(iStream));
5363   m_processInfo->GetVideoSettingsLocked().SetAudioStream(iStream);
5364   SynchronizeDemuxer();
5365 }
5366
5367 void CVideoPlayer::GetSubtitleStreamInfo(int index, SubtitleStreamInfo& info) const
5368 {
5369   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5370
5371   if (index == CURRENT_STREAM)
5372     index = m_content.m_subtitleIndex;
5373
5374   if (index < 0 || index > GetSubtitleCount() - 1)
5375   {
5376     info.valid = false;
5377     info.language.clear();
5378     info.flags = StreamFlags::FLAG_NONE;
5379     return;
5380   }
5381
5382   const SelectionStream& s = m_content.m_selectionStreams.Get(STREAM_SUBTITLE, index);
5383   info.name = s.name;
5384
5385   if (s.type == STREAM_NONE)
5386     info.name += "(Invalid)";
5387
5388   info.language = s.language;
5389   info.flags = s.flags;
5390 }
5391
5392 void CVideoPlayer::SetSubtitle(int iStream)
5393 {
5394   m_messenger.Put(std::make_shared<CDVDMsgPlayerSetSubtitleStream>(iStream));
5395   m_processInfo->GetVideoSettingsLocked().SetSubtitleStream(iStream);
5396 }
5397
5398 int CVideoPlayer::GetSubtitleCount() const
5399 {
5400   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5401   return m_content.m_selectionStreams.CountType(STREAM_SUBTITLE);
5402 }
5403
5404 int CVideoPlayer::GetSubtitle()
5405 {
5406   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5407   return m_content.m_subtitleIndex;
5408 }
5409
5410 int CVideoPlayer::GetPrograms(std::vector<ProgramInfo>& programs)
5411 {
5412   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5413   programs = m_programs;
5414   return programs.size();
5415 }
5416
5417 void CVideoPlayer::SetProgram(int progId)
5418 {
5419   m_messenger.Put(std::make_shared<CDVDMsgInt>(CDVDMsg::PLAYER_SET_PROGRAM, progId));
5420 }
5421
5422 int CVideoPlayer::GetProgramsCount() const
5423 {
5424   std::unique_lock<CCriticalSection> lock(m_content.m_section);
5425   return m_programs.size();
5426 }
5427
5428 void CVideoPlayer::SetUpdateStreamDetails()
5429 {
5430   m_messenger.Put(std::make_shared<CDVDMsg>(CDVDMsg::PLAYER_SET_UPDATE_STREAM_DETAILS));
5431 }