xbmc/application/ApplicationPlayer.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "ApplicationPlayer.h"
  10
  11 #include "ServiceBroker.h"
  12 #include "cores/DataCacheCore.h"
  13 #include "cores/IPlayer.h"
  14 #include "cores/VideoPlayer/VideoPlayer.h"
  15 #include "cores/playercorefactory/PlayerCoreFactory.h"
  16 #include "guilib/GUIComponent.h"
  17 #include "guilib/GUIWindowManager.h"
  18 #include "settings/AdvancedSettings.h"
  19 #include "settings/SettingsComponent.h"
  20
  21 #include <mutex>
  22
  23 using namespace std::chrono_literals;
  24
  25 std::shared_ptr<const IPlayer> CApplicationPlayer::GetInternal() const
  26 {
  27   std::unique_lock<CCriticalSection> lock(m_playerLock);
  28   return m_pPlayer;
  29 }
  30
  31 std::shared_ptr<IPlayer> CApplicationPlayer::GetInternal()
  32 {
  33   std::unique_lock<CCriticalSection> lock(m_playerLock);
  34   return m_pPlayer;
  35 }
  36
  37 void CApplicationPlayer::ClosePlayer()
  38 {
  39   m_nextItem.pItem.reset();
  40   std::shared_ptr<IPlayer> player = GetInternal();
  41   if (player)
  42   {
  43     CloseFile();
  44     ResetPlayer();
  45   }
  46 }
  47
  48 void CApplicationPlayer::ResetPlayer()
  49 {
  50   // we need to do this directly on the member
  51   std::unique_lock<CCriticalSection> lock(m_playerLock);
  52   m_pPlayer.reset();
  53 }
  54
  55 void CApplicationPlayer::CloseFile(bool reopen)
  56 {
  57   std::shared_ptr<IPlayer> player = GetInternal();
  58   if (player)
  59   {
  60     player->CloseFile(reopen);
  61   }
  62 }
  63
  64 void CApplicationPlayer::CreatePlayer(const CPlayerCoreFactory &factory, const std::string &player, IPlayerCallback& callback)
  65 {
  66   std::unique_lock<CCriticalSection> lock(m_playerLock);
  67   if (!m_pPlayer)
  68   {
  69     CDataCacheCore::GetInstance().Reset();
  70     m_pPlayer = factory.CreatePlayer(player, callback);
  71   }
  72 }
  73
  74 std::string CApplicationPlayer::GetCurrentPlayer() const
  75 {
  76   std::shared_ptr<const IPlayer> player = GetInternal();
  77   if (player)
  78   {
  79     return player->m_name;
  80   }
  81   return "";
  82 }
  83
  84 bool CApplicationPlayer::OpenFile(const CFileItem& item, const CPlayerOptions& options,
  85                                   const CPlayerCoreFactory &factory,
  86                                   const std::string &playerName, IPlayerCallback& callback)
  87 {
  88   // get player type
  89   std::string newPlayer;
  90   if (!playerName.empty())
  91     newPlayer = playerName;
  92   else
  93     newPlayer = factory.GetDefaultPlayer(item);
  94
  95   // check if we need to close current player
  96   // VideoPlayer can open a new file while playing
  97   std::shared_ptr<IPlayer> player = GetInternal();
  98   if (player && player->IsPlaying())
  99   {
 100     bool needToClose = false;
 101
 102     if (item.IsDiscImage() || item.IsDVDFile())
 103       needToClose = true;
 104
 105     if (player->m_name != newPlayer)
 106       needToClose = true;
 107
 108     if (player->m_type != "video" && player->m_type != "remote")
 109       needToClose = true;
 110
 111     if (needToClose)
 112     {
 113       m_nextItem.pItem = std::make_shared<CFileItem>(item);
 114       m_nextItem.options = options;
 115       m_nextItem.playerName = newPlayer;
 116       m_nextItem.callback = &callback;
 117
 118       CloseFile();
 119       if (player->m_name != newPlayer)
 120       {
 121         std::unique_lock<CCriticalSection> lock(m_playerLock);
 122         m_pPlayer.reset();
 123       }
 124       return true;
 125     }
 126   }
 127   else if (player && player->m_name != newPlayer)
 128   {
 129     CloseFile();
 130     {
 131       std::unique_lock<CCriticalSection> lock(m_playerLock);
 132       m_pPlayer.reset();
 133       player.reset();
 134     }
 135   }
 136
 137   if (!player)
 138   {
 139     CreatePlayer(factory, newPlayer, callback);
 140     player = GetInternal();
 141     if (!player)
 142       return false;
 143   }
 144
 145   bool ret = player->OpenFile(item, options);
 146
 147   m_nextItem.pItem.reset();
 148
 149   // reset caching timers
 150   m_audioStreamUpdate.SetExpired();
 151   m_videoStreamUpdate.SetExpired();
 152   m_subtitleStreamUpdate.SetExpired();
 153
 154   return ret;
 155 }
 156
 157 void CApplicationPlayer::OpenNext(const CPlayerCoreFactory &factory)
 158 {
 159   if (m_nextItem.pItem)
 160   {
 161     OpenFile(*m_nextItem.pItem, m_nextItem.options,
 162              factory,
 163              m_nextItem.playerName, *m_nextItem.callback);
 164     m_nextItem.pItem.reset();
 165   }
 166 }
 167
 168 bool CApplicationPlayer::HasPlayer() const
 169 {
 170   std::shared_ptr<const IPlayer> player = GetInternal();
 171   return player != nullptr;
 172 }
 173
 174 int CApplicationPlayer::GetChapter() const
 175 {
 176   const std::shared_ptr<const IPlayer> player = GetInternal();
 177   if (player)
 178     return player->GetChapter();
 179   else
 180     return -1;
 181 }
 182
 183 int CApplicationPlayer::GetChapterCount() const
 184 {
 185   const std::shared_ptr<const IPlayer> player = GetInternal();
 186   if (player)
 187     return player->GetChapterCount();
 188   else
 189     return 0;
 190 }
 191
 192 void CApplicationPlayer::GetChapterName(std::string& strChapterName, int chapterIdx) const
 193 {
 194   const std::shared_ptr<const IPlayer> player = GetInternal();
 195   if (player)
 196     player->GetChapterName(strChapterName, chapterIdx);
 197 }
 198
 199 int64_t CApplicationPlayer::GetChapterPos(int chapterIdx) const
 200 {
 201   const std::shared_ptr<const IPlayer> player = GetInternal();
 202   if (player)
 203     return player->GetChapterPos(chapterIdx);
 204
 205   return -1;
 206 }
 207
 208 bool CApplicationPlayer::HasAudio() const
 209 {
 210   std::shared_ptr<const IPlayer> player = GetInternal();
 211   return (player && player->HasAudio());
 212 }
 213
 214 bool CApplicationPlayer::HasVideo() const
 215 {
 216   std::shared_ptr<const IPlayer> player = GetInternal();
 217   return (player && player->HasVideo());
 218 }
 219
 220 bool CApplicationPlayer::HasGame() const
 221 {
 222   std::shared_ptr<const IPlayer> player = GetInternal();
 223   return (player && player->HasGame());
 224 }
 225
 226 PLAYLIST::Id CApplicationPlayer::GetPreferredPlaylist() const
 227 {
 228   if (IsPlayingVideo())
 229     return PLAYLIST::TYPE_VIDEO;
 230
 231   if (IsPlayingAudio())
 232     return PLAYLIST::TYPE_MUSIC;
 233
 234   return PLAYLIST::TYPE_NONE;
 235 }
 236
 237 bool CApplicationPlayer::HasRDS() const
 238 {
 239   std::shared_ptr<const IPlayer> player = GetInternal();
 240   return (player && player->HasRDS());
 241 }
 242
 243 bool CApplicationPlayer::IsPaused() const
 244 {
 245   return (GetPlaySpeed() == 0);
 246 }
 247
 248 bool CApplicationPlayer::IsPlaying() const
 249 {
 250   std::shared_ptr<const IPlayer> player = GetInternal();
 251   return (player && player->IsPlaying());
 252 }
 253
 254 bool CApplicationPlayer::IsPausedPlayback() const
 255 {
 256   return (IsPlaying() && (GetPlaySpeed() == 0));
 257 }
 258
 259 bool CApplicationPlayer::IsPlayingAudio() const
 260 {
 261   return (IsPlaying() && !HasVideo() && HasAudio());
 262 }
 263
 264 bool CApplicationPlayer::IsPlayingVideo() const
 265 {
 266   return (IsPlaying() && HasVideo());
 267 }
 268
 269 bool CApplicationPlayer::IsPlayingGame() const
 270 {
 271   return (IsPlaying() && HasGame());
 272 }
 273
 274 bool CApplicationPlayer::IsPlayingRDS() const
 275 {
 276   return (IsPlaying() && HasRDS());
 277 }
 278
 279 void CApplicationPlayer::Pause()
 280 {
 281   std::shared_ptr<IPlayer> player = GetInternal();
 282   if (player)
 283   {
 284     player->Pause();
 285   }
 286 }
 287
 288 void CApplicationPlayer::SetMute(bool bOnOff)
 289 {
 290   std::shared_ptr<IPlayer> player = GetInternal();
 291   if (player)
 292     player->SetMute(bOnOff);
 293 }
 294
 295 void CApplicationPlayer::SetVolume(float volume)
 296 {
 297   std::shared_ptr<IPlayer> player = GetInternal();
 298   if (player)
 299     player->SetVolume(volume);
 300 }
 301
 302 void CApplicationPlayer::Seek(bool bPlus, bool bLargeStep, bool bChapterOverride)
 303 {
 304   std::shared_ptr<IPlayer> player = GetInternal();
 305   if (player)
 306     player->Seek(bPlus, bLargeStep, bChapterOverride);
 307 }
 308
 309 void CApplicationPlayer::SeekPercentage(float fPercent)
 310 {
 311   std::shared_ptr<IPlayer> player = GetInternal();
 312   if (player)
 313     player->SeekPercentage(fPercent);
 314 }
 315
 316 bool CApplicationPlayer::IsPassthrough() const
 317 {
 318   std::shared_ptr<const IPlayer> player = GetInternal();
 319   return (player && player->IsPassthrough());
 320 }
 321
 322 bool CApplicationPlayer::CanSeek() const
 323 {
 324   const std::shared_ptr<const IPlayer> player = GetInternal();
 325   return (player && player->CanSeek());
 326 }
 327
 328 bool CApplicationPlayer::SeekScene(bool bPlus)
 329 {
 330   std::shared_ptr<IPlayer> player = GetInternal();
 331   return (player && player->SeekScene(bPlus));
 332 }
 333
 334 void CApplicationPlayer::SeekTime(int64_t iTime)
 335 {
 336   std::shared_ptr<IPlayer> player = GetInternal();
 337   if (player)
 338     player->SeekTime(iTime);
 339 }
 340
 341 void CApplicationPlayer::SeekTimeRelative(int64_t iTime)
 342 {
 343   std::shared_ptr<IPlayer> player = GetInternal();
 344   if (player)
 345   {
 346     // use relative seeking if implemented by player
 347     if (!player->SeekTimeRelative(iTime))
 348     {
 349       int64_t abstime = GetTime() + iTime;
 350       player->SeekTime(abstime);
 351     }
 352   }
 353 }
 354
 355 int64_t CApplicationPlayer::GetTime() const
 356 {
 357   std::shared_ptr<const IPlayer> player = GetInternal();
 358   if (player)
 359     return CDataCacheCore::GetInstance().GetPlayTime();
 360   else
 361     return 0;
 362 }
 363
 364 int64_t CApplicationPlayer::GetMinTime() const
 365 {
 366   std::shared_ptr<const IPlayer> player = GetInternal();
 367   if (player)
 368     return CDataCacheCore::GetInstance().GetMinTime();
 369   else
 370     return 0;
 371 }
 372
 373 int64_t CApplicationPlayer::GetMaxTime() const
 374 {
 375   std::shared_ptr<const IPlayer> player = GetInternal();
 376   if (player)
 377     return CDataCacheCore::GetInstance().GetMaxTime();
 378   else
 379     return 0;
 380 }
 381
 382 time_t CApplicationPlayer::GetStartTime() const
 383 {
 384   std::shared_ptr<const IPlayer> player = GetInternal();
 385   if (player)
 386     return CDataCacheCore::GetInstance().GetStartTime();
 387   else
 388     return 0;
 389 }
 390
 391 int64_t CApplicationPlayer::GetTotalTime() const
 392 {
 393   std::shared_ptr<const IPlayer> player = GetInternal();
 394   if (player)
 395   {
 396     int64_t total = CDataCacheCore::GetInstance().GetMaxTime() - CDataCacheCore::GetInstance().GetMinTime();
 397     return total;
 398   }
 399   else
 400     return 0;
 401 }
 402
 403 bool CApplicationPlayer::IsCaching() const
 404 {
 405   std::shared_ptr<const IPlayer> player = GetInternal();
 406   return (player && player->IsCaching());
 407 }
 408
 409 bool CApplicationPlayer::IsInMenu() const
 410 {
 411   std::shared_ptr<const IPlayer> player = GetInternal();
 412   return (player && player->IsInMenu());
 413 }
 414
 415 MenuType CApplicationPlayer::GetSupportedMenuType() const
 416 {
 417   std::shared_ptr<const IPlayer> player = GetInternal();
 418   if (!player)
 419   {
 420     return MenuType::NONE;
 421   }
 422   return player->GetSupportedMenuType();
 423 }
 424
 425 int CApplicationPlayer::GetCacheLevel() const
 426 {
 427   std::shared_ptr<const IPlayer> player = GetInternal();
 428   if (player)
 429     return player->GetCacheLevel();
 430   else
 431     return 0;
 432 }
 433
 434 int CApplicationPlayer::GetSubtitleCount() const
 435 {
 436   const std::shared_ptr<const IPlayer> player = GetInternal();
 437   if (player)
 438     return player->GetSubtitleCount();
 439   else
 440     return 0;
 441 }
 442
 443 int CApplicationPlayer::GetAudioStream()
 444 {
 445   if (!m_audioStreamUpdate.IsTimePast())
 446     return m_iAudioStream;
 447
 448   std::shared_ptr<IPlayer> player = GetInternal();
 449   if (player)
 450   {
 451     m_iAudioStream = player->GetAudioStream();
 452     m_audioStreamUpdate.Set(1000ms);
 453     return m_iAudioStream;
 454   }
 455   else
 456     return 0;
 457 }
 458
 459 int CApplicationPlayer::GetSubtitle()
 460 {
 461   if (!m_subtitleStreamUpdate.IsTimePast())
 462     return m_iSubtitleStream;
 463
 464   std::shared_ptr<IPlayer> player = GetInternal();
 465   if (player)
 466   {
 467     m_iSubtitleStream = player->GetSubtitle();
 468     m_subtitleStreamUpdate.Set(1000ms);
 469     return m_iSubtitleStream;
 470   }
 471   else
 472     return 0;
 473 }
 474
 475 bool CApplicationPlayer::GetSubtitleVisible() const
 476 {
 477   const std::shared_ptr<const IPlayer> player = GetInternal();
 478   return player && player->GetSubtitleVisible();
 479 }
 480
 481 bool CApplicationPlayer::CanPause() const
 482 {
 483   const std::shared_ptr<const IPlayer> player = GetInternal();
 484   return (player && player->CanPause());
 485 }
 486
 487 bool CApplicationPlayer::HasTeletextCache() const
 488 {
 489   const std::shared_ptr<const IPlayer> player = GetInternal();
 490   if (player)
 491     return player->HasTeletextCache();
 492   else
 493     return false;
 494 }
 495
 496 std::shared_ptr<TextCacheStruct_t> CApplicationPlayer::GetTeletextCache()
 497 {
 498   std::shared_ptr<IPlayer> player = GetInternal();
 499   if (player)
 500     return player->GetTeletextCache();
 501   else
 502     return {};
 503 }
 504
 505 float CApplicationPlayer::GetPercentage() const
 506 {
 507   std::shared_ptr<const IPlayer> player = GetInternal();
 508   if (player)
 509   {
 510     float fPercent = CDataCacheCore::GetInstance().GetPlayPercentage();
 511     return std::max(0.0f, std::min(fPercent, 100.0f));
 512   }
 513   else
 514     return 0.0;
 515 }
 516
 517 float CApplicationPlayer::GetCachePercentage() const
 518 {
 519   std::shared_ptr<const IPlayer> player = GetInternal();
 520   if (player)
 521     return player->GetCachePercentage();
 522   else
 523     return 0.0;
 524 }
 525
 526 void CApplicationPlayer::SetSpeed(float speed)
 527 {
 528   std::shared_ptr<IPlayer> player = GetInternal();
 529   if (player)
 530     player->SetSpeed(speed);
 531 }
 532
 533 void CApplicationPlayer::SetTempo(float tempo)
 534 {
 535   std::shared_ptr<IPlayer> player = GetInternal();
 536   if (player)
 537     player->SetTempo(tempo);
 538 }
 539
 540 void CApplicationPlayer::FrameAdvance(int frames)
 541 {
 542   std::shared_ptr<IPlayer> player = GetInternal();
 543   if (player)
 544     player->FrameAdvance(frames);
 545 }
 546
 547 std::string CApplicationPlayer::GetPlayerState()
 548 {
 549   std::shared_ptr<IPlayer> player = GetInternal();
 550   if (player)
 551     return player->GetPlayerState();
 552   else
 553     return "";
 554 }
 555
 556 bool CApplicationPlayer::QueueNextFile(const CFileItem &file)
 557 {
 558   std::shared_ptr<IPlayer> player = GetInternal();
 559   return (player && player->QueueNextFile(file));
 560 }
 561
 562 bool CApplicationPlayer::SetPlayerState(const std::string& state)
 563 {
 564   std::shared_ptr<IPlayer> player = GetInternal();
 565   return (player && player->SetPlayerState(state));
 566 }
 567
 568 void CApplicationPlayer::OnNothingToQueueNotify()
 569 {
 570   std::shared_ptr<IPlayer> player = GetInternal();
 571   if (player)
 572     player->OnNothingToQueueNotify();
 573 }
 574
 575 void CApplicationPlayer::GetVideoStreamInfo(int streamId, VideoStreamInfo& info) const
 576 {
 577   const std::shared_ptr<const IPlayer> player = GetInternal();
 578   if (player)
 579     player->GetVideoStreamInfo(streamId, info);
 580 }
 581
 582 void CApplicationPlayer::GetAudioStreamInfo(int index, AudioStreamInfo& info) const
 583 {
 584   const std::shared_ptr<const IPlayer> player = GetInternal();
 585   if (player)
 586     player->GetAudioStreamInfo(index, info);
 587 }
 588
 589 int CApplicationPlayer::GetPrograms(std::vector<ProgramInfo> &programs)
 590 {
 591   int ret = 0;
 592   std::shared_ptr<IPlayer> player = GetInternal();
 593   if (player)
 594     ret = player->GetPrograms(programs);
 595   return ret;
 596 }
 597
 598 void CApplicationPlayer::SetProgram(int progId)
 599 {
 600   std::shared_ptr<IPlayer> player = GetInternal();
 601   if (player)
 602     player->SetProgram(progId);
 603 }
 604
 605 int CApplicationPlayer::GetProgramsCount() const
 606 {
 607   int ret = 0;
 608   const std::shared_ptr<const IPlayer> player = GetInternal();
 609   if (player)
 610     ret = player->GetProgramsCount();
 611   return ret;
 612 }
 613
 614 bool CApplicationPlayer::OnAction(const CAction &action)
 615 {
 616   std::shared_ptr<IPlayer> player = GetInternal();
 617   return (player && player->OnAction(action));
 618 }
 619
 620 int CApplicationPlayer::GetAudioStreamCount() const
 621 {
 622   const std::shared_ptr<const IPlayer> player = GetInternal();
 623   if (player)
 624     return player->GetAudioStreamCount();
 625   else
 626     return 0;
 627 }
 628
 629 int CApplicationPlayer::GetVideoStream()
 630 {
 631   if (!m_videoStreamUpdate.IsTimePast())
 632     return m_iVideoStream;
 633
 634   std::shared_ptr<IPlayer> player = GetInternal();
 635   if (player)
 636   {
 637     m_iVideoStream = player->GetVideoStream();
 638     m_videoStreamUpdate.Set(1000ms);
 639     return m_iVideoStream;
 640   }
 641   else
 642     return 0;
 643 }
 644
 645 int CApplicationPlayer::GetVideoStreamCount() const
 646 {
 647   const std::shared_ptr<const IPlayer> player = GetInternal();
 648   if (player)
 649     return player->GetVideoStreamCount();
 650   else
 651     return 0;
 652 }
 653
 654 void CApplicationPlayer::SetAudioStream(int iStream)
 655 {
 656   std::shared_ptr<IPlayer> player = GetInternal();
 657   if (player)
 658   {
 659     player->SetAudioStream(iStream);
 660     m_iAudioStream = iStream;
 661     m_audioStreamUpdate.Set(1000ms);
 662   }
 663 }
 664
 665 void CApplicationPlayer::GetSubtitleStreamInfo(int index, SubtitleStreamInfo& info) const
 666 {
 667   const std::shared_ptr<const IPlayer> player = GetInternal();
 668   if (player)
 669     player->GetSubtitleStreamInfo(index, info);
 670 }
 671
 672 void CApplicationPlayer::SetSubtitle(int iStream)
 673 {
 674   std::shared_ptr<IPlayer> player = GetInternal();
 675   if (player)
 676   {
 677     player->SetSubtitle(iStream);
 678     m_iSubtitleStream = iStream;
 679     m_subtitleStreamUpdate.Set(1000ms);
 680   }
 681 }
 682
 683 void CApplicationPlayer::SetSubtitleVisible(bool bVisible)
 684 {
 685   std::shared_ptr<IPlayer> player = GetInternal();
 686   if (player)
 687   {
 688     player->SetSubtitleVisible(bVisible);
 689   }
 690 }
 691
 692 void CApplicationPlayer::SetSubtitleVerticalPosition(int value, bool save)
 693 {
 694   std::shared_ptr<IPlayer> player = GetInternal();
 695   if (player)
 696   {
 697     player->SetSubtitleVerticalPosition(value, save);
 698   }
 699 }
 700
 701 void CApplicationPlayer::SetTime(int64_t time)
 702 {
 703   std::shared_ptr<IPlayer> player = GetInternal();
 704   if (player)
 705     return player->SetTime(time);
 706 }
 707
 708 void CApplicationPlayer::SetTotalTime(int64_t time)
 709 {
 710   std::shared_ptr<IPlayer> player = GetInternal();
 711   if (player)
 712     player->SetTotalTime(time);
 713 }
 714
 715 void CApplicationPlayer::SetVideoStream(int iStream)
 716 {
 717   std::shared_ptr<IPlayer> player = GetInternal();
 718   if (player)
 719   {
 720     player->SetVideoStream(iStream);
 721     m_iVideoStream = iStream;
 722     m_videoStreamUpdate.Set(1000ms);
 723   }
 724 }
 725
 726 void CApplicationPlayer::AddSubtitle(const std::string& strSubPath)
 727 {
 728   std::shared_ptr<IPlayer> player = GetInternal();
 729   if (player)
 730     player->AddSubtitle(strSubPath);
 731 }
 732
 733 void CApplicationPlayer::SetSubTitleDelay(float fValue)
 734 {
 735   std::shared_ptr<IPlayer> player = GetInternal();
 736   if (player)
 737     player->SetSubTitleDelay(fValue);
 738 }
 739
 740 void CApplicationPlayer::SetAVDelay(float fValue)
 741 {
 742   std::shared_ptr<IPlayer> player = GetInternal();
 743   if (player)
 744     player->SetAVDelay(fValue);
 745 }
 746
 747 void CApplicationPlayer::SetDynamicRangeCompression(long drc)
 748 {
 749   std::shared_ptr<IPlayer> player = GetInternal();
 750   if (player)
 751     player->SetDynamicRangeCompression(drc);
 752 }
 753
 754 void CApplicationPlayer::LoadPage(int p, int sp, unsigned char* buffer)
 755 {
 756   std::shared_ptr<IPlayer> player = GetInternal();
 757   if (player)
 758     player->LoadPage(p, sp, buffer);
 759 }
 760
 761 void CApplicationPlayer::GetAudioCapabilities(std::vector<int>& audioCaps) const
 762 {
 763   const std::shared_ptr<const IPlayer> player = GetInternal();
 764   if (player)
 765     player->GetAudioCapabilities(audioCaps);
 766 }
 767
 768 void CApplicationPlayer::GetSubtitleCapabilities(std::vector<int>& subCaps) const
 769 {
 770   const std::shared_ptr<const IPlayer> player = GetInternal();
 771   if (player)
 772     player->GetSubtitleCapabilities(subCaps);
 773 }
 774
 775 int  CApplicationPlayer::SeekChapter(int iChapter)
 776 {
 777   std::shared_ptr<IPlayer> player = GetInternal();
 778   if (player)
 779     return player->SeekChapter(iChapter);
 780   else
 781     return 0;
 782 }
 783
 784 void CApplicationPlayer::SetPlaySpeed(float speed)
 785 {
 786   std::shared_ptr<IPlayer> player = GetInternal();
 787   if (!player)
 788     return;
 789
 790   if (!IsPlayingAudio() && !IsPlayingVideo())
 791     return ;
 792
 793   SetSpeed(speed);
 794 }
 795
 796 float CApplicationPlayer::GetPlaySpeed() const
 797 {
 798   std::shared_ptr<const IPlayer> player = GetInternal();
 799   if (player)
 800   {
 801     return CDataCacheCore::GetInstance().GetSpeed();
 802   }
 803   else
 804     return 0;
 805 }
 806
 807 float CApplicationPlayer::GetPlayTempo() const
 808 {
 809   std::shared_ptr<const IPlayer> player = GetInternal();
 810   if (player)
 811   {
 812     return CDataCacheCore::GetInstance().GetTempo();
 813   }
 814   else
 815     return 0;
 816 }
 817
 818 bool CApplicationPlayer::SupportsTempo() const
 819 {
 820   const std::shared_ptr<const IPlayer> player = GetInternal();
 821   if (player)
 822     return player->SupportsTempo();
 823   else
 824     return false;
 825 }
 826
 827 void CApplicationPlayer::FrameMove()
 828 {
 829   std::shared_ptr<IPlayer> player = GetInternal();
 830   if (player)
 831   {
 832     if (CDataCacheCore::GetInstance().IsPlayerStateChanged())
 833       // CApplicationMessenger would be overhead because we are already in gui thread
 834       CServiceBroker::GetGUI()->GetWindowManager().SendMessage(GUI_MSG_NOTIFY_ALL, 0, 0, GUI_MSG_STATE_CHANGED);
 835   }
 836 }
 837
 838 void CApplicationPlayer::Render(bool clear, uint32_t alpha, bool gui)
 839 {
 840   std::shared_ptr<IPlayer> player = GetInternal();
 841   if (player)
 842     player->Render(clear, alpha, gui);
 843 }
 844
 845 void CApplicationPlayer::FlushRenderer()
 846 {
 847   std::shared_ptr<IPlayer> player = GetInternal();
 848   if (player)
 849     player->FlushRenderer();
 850 }
 851
 852 void CApplicationPlayer::SetRenderViewMode(int mode, float zoom, float par, float shift, bool stretch)
 853 {
 854   std::shared_ptr<IPlayer> player = GetInternal();
 855   if (player)
 856     player->SetRenderViewMode(mode, zoom, par, shift, stretch);
 857 }
 858
 859 float CApplicationPlayer::GetRenderAspectRatio() const
 860 {
 861   const std::shared_ptr<const IPlayer> player = GetInternal();
 862   if (player)
 863     return player->GetRenderAspectRatio();
 864   else
 865     return 1.0;
 866 }
 867
 868 void CApplicationPlayer::TriggerUpdateResolution()
 869 {
 870   std::shared_ptr<IPlayer> player = GetInternal();
 871   if (player)
 872     player->TriggerUpdateResolution();
 873 }
 874
 875 bool CApplicationPlayer::IsRenderingVideo() const
 876 {
 877   const std::shared_ptr<const IPlayer> player = GetInternal();
 878   if (player)
 879     return player->IsRenderingVideo();
 880   else
 881     return false;
 882 }
 883
 884 bool CApplicationPlayer::IsRenderingGuiLayer() const
 885 {
 886   const std::shared_ptr<const IPlayer> player = GetInternal();
 887   if (player)
 888     return CServiceBroker::GetDataCacheCore().GetGuiRender();
 889   else
 890     return false;
 891 }
 892
 893 bool CApplicationPlayer::IsRenderingVideoLayer() const
 894 {
 895   const std::shared_ptr<const IPlayer> player = GetInternal();
 896   if (player)
 897     return CServiceBroker::GetDataCacheCore().GetVideoRender();
 898   else
 899     return false;
 900 }
 901
 902 bool CApplicationPlayer::Supports(EINTERLACEMETHOD method) const
 903 {
 904   const std::shared_ptr<const IPlayer> player = GetInternal();
 905   if (player)
 906     return player->Supports(method);
 907   else
 908     return false;
 909 }
 910
 911 EINTERLACEMETHOD CApplicationPlayer::GetDeinterlacingMethodDefault() const
 912 {
 913   const std::shared_ptr<const IPlayer> player = GetInternal();
 914   if (player)
 915     return player->GetDeinterlacingMethodDefault();
 916   else
 917     return EINTERLACEMETHOD::VS_INTERLACEMETHOD_NONE;
 918 }
 919
 920 bool CApplicationPlayer::Supports(ESCALINGMETHOD method) const
 921 {
 922   const std::shared_ptr<const IPlayer> player = GetInternal();
 923   if (player)
 924     return player->Supports(method);
 925   else
 926     return false;
 927 }
 928
 929 bool CApplicationPlayer::Supports(ERENDERFEATURE feature) const
 930 {
 931   const std::shared_ptr<const IPlayer> player = GetInternal();
 932   if (player)
 933     return player->Supports(feature);
 934   else
 935     return false;
 936 }
 937
 938 unsigned int CApplicationPlayer::RenderCaptureAlloc()
 939 {
 940   std::shared_ptr<IPlayer> player = GetInternal();
 941   if (player)
 942     return player->RenderCaptureAlloc();
 943   else
 944     return 0;
 945 }
 946
 947 void CApplicationPlayer::RenderCapture(unsigned int captureId, unsigned int width, unsigned int height, int flags)
 948 {
 949   std::shared_ptr<IPlayer> player = GetInternal();
 950   if (player)
 951     player->RenderCapture(captureId, width, height, flags);
 952 }
 953
 954 void CApplicationPlayer::RenderCaptureRelease(unsigned int captureId)
 955 {
 956   std::shared_ptr<IPlayer> player = GetInternal();
 957   if (player)
 958     player->RenderCaptureRelease(captureId);
 959 }
 960
 961 bool CApplicationPlayer::RenderCaptureGetPixels(unsigned int captureId, unsigned int millis, uint8_t *buffer, unsigned int size)
 962 {
 963   std::shared_ptr<IPlayer> player = GetInternal();
 964   if (player)
 965     return player->RenderCaptureGetPixels(captureId, millis, buffer, size);
 966   else
 967     return false;
 968 }
 969
 970 bool CApplicationPlayer::IsExternalPlaying() const
 971 {
 972   const std::shared_ptr<const IPlayer> player = GetInternal();
 973   if (player)
 974   {
 975     if (player->IsPlaying() && player->m_type == "external")
 976       return true;
 977   }
 978   return false;
 979 }
 980
 981 bool CApplicationPlayer::IsRemotePlaying() const
 982 {
 983   const std::shared_ptr<const IPlayer> player = GetInternal();
 984   if (player)
 985   {
 986     if (player->IsPlaying() && player->m_type == "remote")
 987       return true;
 988   }
 989   return false;
 990 }
 991
 992 std::string CApplicationPlayer::GetName() const
 993 {
 994   const std::shared_ptr<const IPlayer> player = GetInternal();
 995   if (player)
 996   {
 997     return player->m_name;
 998   }
 999   return {};
1000 }
1001
1002 CVideoSettings CApplicationPlayer::GetVideoSettings() const
1003 {
1004   std::shared_ptr<const IPlayer> player = GetInternal();
1005   if (player)
1006   {
1007     return player->GetVideoSettings();
1008   }
1009   return CVideoSettings();
1010 }
1011
1012 void CApplicationPlayer::SetVideoSettings(CVideoSettings& settings)
1013 {
1014   std::shared_ptr<IPlayer> player = GetInternal();
1015   if (player)
1016   {
1017     return player->SetVideoSettings(settings);
1018   }
1019 }
1020
1021 CSeekHandler& CApplicationPlayer::GetSeekHandler()
1022 {
1023   return m_seekHandler;
1024 }
1025
1026 const CSeekHandler& CApplicationPlayer::GetSeekHandler() const
1027 {
1028   return m_seekHandler;
1029 }
1030
1031 void CApplicationPlayer::SetUpdateStreamDetails()
1032 {
1033   std::shared_ptr<IPlayer> player = GetInternal();
1034   CVideoPlayer* vp = dynamic_cast<CVideoPlayer*>(player.get());
1035   if (vp)
1036     vp->SetUpdateStreamDetails();
1037 }
1038
1039 bool CApplicationPlayer::HasGameAgent() const
1040 {
1041   const std::shared_ptr<const IPlayer> player = GetInternal();
1042   if (player)
1043     return player->HasGameAgent();
1044
1045   return false;
1046 }
1047
1048 int CApplicationPlayer::GetSubtitleDelay() const
1049 {
1050   // converts subtitle delay to a percentage
1051   const auto& advSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
1052   const auto delay = this->GetVideoSettings().m_SubtitleDelay;
1053   const auto range = advSettings->m_videoSubsDelayRange;
1054   return static_cast<int>(0.5f + (delay + range) / (2.f * range) * 100.0f);
1055 }
1056
1057 int CApplicationPlayer::GetAudioDelay() const
1058 {
1059   // converts audio delay to a percentage
1060   const auto& advSettings = CServiceBroker::GetSettingsComponent()->GetAdvancedSettings();
1061   const auto delay = this->GetVideoSettings().m_AudioDelay;
1062   const auto range = advSettings->m_videoAudioDelayRange;
1063   return static_cast<int>(0.5f + (delay + range) / (2.f * range) * 100.0f);
1064 }