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