code.vuplus.com Git - vuplus_xbmc/blob - xbmc/ApplicationPlayer.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "ApplicationPlayer.h"
  22 #include "cores/IPlayer.h"
  23 #include "Application.h"
  24
  25 #define VOLUME_MINIMUM 0.0f        // -60dB
  26 #define VOLUME_MAXIMUM 1.0f        // 0dB
  27
  28 CApplicationPlayer::CApplicationPlayer()
  29 {
  30   m_iPlayerOPSeq = 0;
  31   m_eCurrentPlayer = EPC_NONE;
  32 }
  33
  34 boost::shared_ptr<IPlayer> CApplicationPlayer::GetInternal() const
  35 {
  36   CSingleLock lock(m_player_lock);
  37   return m_pPlayer;
  38 }
  39
  40 void CApplicationPlayer::ClosePlayer()
  41 {
  42   boost::shared_ptr<IPlayer> player = GetInternal();
  43   if (player)
  44   {
  45     CloseFile();
  46     // we need to do this directly on the member
  47     CSingleLock lock(m_player_lock);
  48     m_pPlayer.reset();
  49   }
  50 }
  51
  52 void CApplicationPlayer::CloseFile(bool reopen)
  53 {
  54   boost::shared_ptr<IPlayer> player = GetInternal();
  55   if (player)
  56   {
  57     ++m_iPlayerOPSeq;
  58     player->CloseFile(reopen);
  59   }
  60 }
  61
  62 void CApplicationPlayer::ClosePlayerGapless(PLAYERCOREID newCore)
  63 {
  64   boost::shared_ptr<IPlayer> player = GetInternal();
  65   if (!player)
  66     return;
  67
  68   bool gaplessSupported = (m_eCurrentPlayer == EPC_DVDPLAYER || m_eCurrentPlayer == EPC_PAPLAYER);
  69 #if defined(HAS_OMXPLAYER)
  70   gaplessSupported = gaplessSupported || (m_eCurrentPlayer == EPC_OMXPLAYER);
  71 #endif
  72   gaplessSupported = gaplessSupported && (m_eCurrentPlayer == newCore);
  73   if (!gaplessSupported)
  74   {
  75     ClosePlayer();
  76   }
  77   else
  78   {
  79     // XXX: we had to stop the previous playing item, it was done in dvdplayer::OpenFile.
  80     // but in paplayer::OpenFile, it sometimes just fade in without call CloseFile.
  81     // but if we do not stop it, we can not distingush callbacks from previous
  82     // item and current item, it will confused us then we can not make correct delay
  83     // callback after the starting state.
  84     CloseFile(true);
  85   }
  86 }
  87
  88 void CApplicationPlayer::CreatePlayer(PLAYERCOREID newCore, IPlayerCallback& callback)
  89 {
  90   CSingleLock lock(m_player_lock);
  91   if (!m_pPlayer)
  92   {
  93     m_eCurrentPlayer = newCore;
  94     m_pPlayer.reset(CPlayerCoreFactory::Get().CreatePlayer(newCore, callback));
  95   }
  96 }
  97
  98 PlayBackRet CApplicationPlayer::OpenFile(const CFileItem& item, const CPlayerOptions& options)
  99 {
 100   boost::shared_ptr<IPlayer> player = GetInternal();
 101   PlayBackRet iResult = PLAYBACK_FAIL;
 102   if (player)
 103   {
 104     // op seq for detect cancel (CloseFile be called or OpenFile be called again) during OpenFile.
 105     unsigned int startingSeq = ++m_iPlayerOPSeq;
 106
 107     iResult = player->OpenFile(item, options) ? PLAYBACK_OK : PLAYBACK_FAIL;
 108     // check whether the OpenFile was canceled by either CloseFile or another OpenFile.
 109     if (m_iPlayerOPSeq != startingSeq)
 110       iResult = PLAYBACK_CANCELED;
 111   }
 112   return iResult;
 113 }
 114
 115 bool CApplicationPlayer::HasPlayer() const
 116 {
 117   boost::shared_ptr<IPlayer> player = GetInternal();
 118   return player != NULL;
 119 }
 120
 121 void CApplicationPlayer::RegisterAudioCallback(IAudioCallback* pCallback)
 122 {
 123   boost::shared_ptr<IPlayer> player = GetInternal();
 124   if (player)
 125     player->RegisterAudioCallback(pCallback);
 126 }
 127
 128 void CApplicationPlayer::UnRegisterAudioCallback()
 129 {
 130   boost::shared_ptr<IPlayer> player = GetInternal();
 131   if (player)
 132     player->UnRegisterAudioCallback();
 133 }
 134
 135 int CApplicationPlayer::GetChapter()
 136 {
 137   boost::shared_ptr<IPlayer> player = GetInternal();
 138   if (player)
 139     return player->GetChapter();
 140   else
 141     return -1;
 142 }
 143
 144 int CApplicationPlayer::GetChapterCount()
 145 {
 146   boost::shared_ptr<IPlayer> player = GetInternal();
 147   if (player)
 148     return player->GetChapterCount();
 149   else
 150     return 0;
 151 }
 152
 153 void CApplicationPlayer::GetChapterName(std::string& strChapterName)
 154 {
 155   boost::shared_ptr<IPlayer> player = GetInternal();
 156   if (player)
 157     player->GetChapterName(strChapterName);
 158 }
 159
 160 bool CApplicationPlayer::HasAudio() const
 161 {
 162   boost::shared_ptr<IPlayer> player = GetInternal();
 163   return (player && player->HasAudio());
 164 }
 165
 166 bool CApplicationPlayer::HasVideo() const
 167 {
 168   boost::shared_ptr<IPlayer> player = GetInternal();
 169   return (player && player->HasVideo());
 170 }
 171
 172 bool CApplicationPlayer::IsPaused() const
 173 {
 174   boost::shared_ptr<IPlayer> player = GetInternal();
 175   return (player && player->IsPaused());
 176 }
 177
 178 bool CApplicationPlayer::IsPlaying() const
 179 {
 180   boost::shared_ptr<IPlayer> player = GetInternal();
 181   return (player && player->IsPlaying());
 182 }
 183
 184 bool CApplicationPlayer::IsPausedPlayback() const
 185 {
 186   return (IsPlaying() && IsPaused());
 187 }
 188
 189 bool CApplicationPlayer::IsPlayingAudio() const
 190 {
 191   return (IsPlaying() && !HasVideo() && HasAudio());
 192 }
 193
 194 bool CApplicationPlayer::IsPlayingVideo() const
 195 {
 196   return (IsPlaying() && HasVideo());
 197 }
 198
 199 void CApplicationPlayer::Pause()
 200 {
 201   boost::shared_ptr<IPlayer> player = GetInternal();
 202   if (player)
 203     player->Pause();
 204 }
 205
 206 bool CApplicationPlayer::ControlsVolume() const
 207 {
 208   boost::shared_ptr<IPlayer> player = GetInternal();
 209   return (player && player->ControlsVolume());
 210 }
 211
 212 void CApplicationPlayer::SetMute(bool bOnOff)
 213 {
 214   boost::shared_ptr<IPlayer> player = GetInternal();
 215   if (player)
 216     player->SetMute(bOnOff);
 217 }
 218
 219 void CApplicationPlayer::SetVolume(float volume)
 220 {
 221   boost::shared_ptr<IPlayer> player = GetInternal();
 222   if (player)
 223     player->SetVolume(volume);
 224 }
 225
 226 void CApplicationPlayer::Seek(bool bPlus, bool bLargeStep, bool bChapterOverride)
 227 {
 228   boost::shared_ptr<IPlayer> player = GetInternal();
 229   if (player)
 230     player->Seek(bPlus, bLargeStep, bChapterOverride);
 231 }
 232
 233 void CApplicationPlayer::SeekPercentage(float fPercent)
 234 {
 235   boost::shared_ptr<IPlayer> player = GetInternal();
 236   if (player)
 237     player->SeekPercentage(fPercent);
 238 }
 239
 240 bool CApplicationPlayer::IsPassthrough() const
 241 {
 242   boost::shared_ptr<IPlayer> player = GetInternal();
 243   return (player && player->IsPassthrough());
 244 }
 245
 246 bool CApplicationPlayer::CanSeek()
 247 {
 248   boost::shared_ptr<IPlayer> player = GetInternal();
 249   return (player && player->CanSeek());
 250 }
 251
 252 bool CApplicationPlayer::SeekScene(bool bPlus)
 253 {
 254   boost::shared_ptr<IPlayer> player = GetInternal();
 255   return (player && player->SeekScene(bPlus));
 256 }
 257
 258 void CApplicationPlayer::SeekTime(int64_t iTime)
 259 {
 260   boost::shared_ptr<IPlayer> player = GetInternal();
 261   if (player)
 262     player->SeekTime(iTime);
 263 }
 264
 265 std::string CApplicationPlayer::GetPlayingTitle()
 266 {
 267   boost::shared_ptr<IPlayer> player = GetInternal();
 268   if (player)
 269     return player->GetPlayingTitle();
 270   else
 271     return "";
 272 }
 273
 274 int64_t CApplicationPlayer::GetTime() const
 275 {
 276   boost::shared_ptr<IPlayer> player = GetInternal();
 277   if (player)
 278     return player->GetTime();
 279   else
 280     return 0;
 281 }
 282
 283 bool CApplicationPlayer::IsCaching() const
 284 {
 285   boost::shared_ptr<IPlayer> player = GetInternal();
 286   return (player && player->IsCaching());
 287 }
 288
 289 bool CApplicationPlayer::IsInMenu() const
 290 {
 291   boost::shared_ptr<IPlayer> player = GetInternal();
 292   return (player && player->IsInMenu());
 293 }
 294
 295 bool CApplicationPlayer::HasMenu() const
 296 {
 297   boost::shared_ptr<IPlayer> player = GetInternal();
 298   return (player && player->HasMenu());
 299 }
 300
 301 int CApplicationPlayer::GetCacheLevel() const
 302 {
 303   boost::shared_ptr<IPlayer> player = GetInternal();
 304   if (player)
 305     return player->GetCacheLevel();
 306   else
 307     return 0;
 308 }
 309
 310 int CApplicationPlayer::GetSubtitleCount()
 311 {
 312   boost::shared_ptr<IPlayer> player = GetInternal();
 313   if (player)
 314     return player->GetSubtitleCount();
 315   else
 316     return 0;
 317 }
 318
 319 int CApplicationPlayer::GetAudioStream()
 320 {
 321   if (!m_audioStreamUpdate.IsTimePast())
 322     return m_iAudioStream;
 323
 324   boost::shared_ptr<IPlayer> player = GetInternal();
 325   if (player)
 326   {
 327     m_iAudioStream = player->GetAudioStream();
 328     m_audioStreamUpdate.Set(1000);
 329     return m_iAudioStream;
 330   }
 331   else
 332     return 0;
 333 }
 334
 335 int CApplicationPlayer::GetSubtitle()
 336 {
 337   if (!m_subtitleStreamUpdate.IsTimePast())
 338     return m_iSubtitleStream;
 339
 340   boost::shared_ptr<IPlayer> player = GetInternal();
 341   if (player)
 342   {
 343     m_iSubtitleStream = player->GetSubtitle();
 344     m_subtitleStreamUpdate.Set(1000);
 345     return m_iSubtitleStream;
 346   }
 347   else
 348     return 0;
 349 }
 350
 351 bool CApplicationPlayer::GetSubtitleVisible()
 352 {
 353   boost::shared_ptr<IPlayer> player = GetInternal();
 354   return (player && player->GetSubtitleVisible());
 355 }
 356
 357 bool CApplicationPlayer::CanRecord()
 358 {
 359   boost::shared_ptr<IPlayer> player = GetInternal();
 360   return (player && player->CanRecord());
 361 }
 362
 363 bool CApplicationPlayer::CanPause()
 364 {
 365   boost::shared_ptr<IPlayer> player = GetInternal();
 366   return (player && player->CanPause());
 367 }
 368
 369 bool CApplicationPlayer::IsRecording() const
 370 {
 371   boost::shared_ptr<IPlayer> player = GetInternal();
 372   return (player && player->IsRecording());
 373 }
 374
 375 TextCacheStruct_t* CApplicationPlayer::GetTeletextCache()
 376 {
 377   boost::shared_ptr<IPlayer> player = GetInternal();
 378   if (player)
 379     return player->GetTeletextCache();
 380   else
 381     return NULL;
 382 }
 383
 384 int64_t CApplicationPlayer::GetTotalTime() const
 385 {
 386   boost::shared_ptr<IPlayer> player = GetInternal();
 387   if (player)
 388     return player->GetTotalTime();
 389   else
 390     return 0;
 391 }
 392
 393 float CApplicationPlayer::GetPercentage() const
 394 {
 395   boost::shared_ptr<IPlayer> player = GetInternal();
 396   if (player)
 397     return player->GetPercentage();
 398   else
 399     return 0.0;
 400 }
 401
 402 float CApplicationPlayer::GetCachePercentage() const
 403 {
 404   boost::shared_ptr<IPlayer> player = GetInternal();
 405   if (player)
 406     return player->GetCachePercentage();
 407   else
 408     return 0.0;
 409 }
 410
 411 void CApplicationPlayer::ToFFRW(int iSpeed)
 412 {
 413   boost::shared_ptr<IPlayer> player = GetInternal();
 414   if (player)
 415     player->ToFFRW(iSpeed);
 416 }
 417
 418 void CApplicationPlayer::DoAudioWork()
 419 {
 420   boost::shared_ptr<IPlayer> player = GetInternal();
 421   if (player)
 422     player->DoAudioWork();
 423 }
 424
 425 std::string CApplicationPlayer::GetPlayerState()
 426 {
 427   boost::shared_ptr<IPlayer> player = GetInternal();
 428   if (player)
 429     return player->GetPlayerState();
 430   else
 431     return "";
 432 }
 433
 434 bool CApplicationPlayer::QueueNextFile(const CFileItem &file)
 435 {
 436   boost::shared_ptr<IPlayer> player = GetInternal();
 437   return (player && player->QueueNextFile(file));
 438 }
 439
 440 bool CApplicationPlayer::GetStreamDetails(CStreamDetails &details)
 441 {
 442   boost::shared_ptr<IPlayer> player = GetInternal();
 443   return (player && player->GetStreamDetails(details));
 444 }
 445
 446 bool CApplicationPlayer::SetPlayerState(const std::string& state)
 447 {
 448   boost::shared_ptr<IPlayer> player = GetInternal();
 449   return (player && player->SetPlayerState(state));
 450 }
 451
 452 void CApplicationPlayer::OnNothingToQueueNotify()
 453 {
 454   boost::shared_ptr<IPlayer> player = GetInternal();
 455   if (player)
 456     player->OnNothingToQueueNotify();
 457 }
 458
 459 void CApplicationPlayer::GetVideoStreamInfo(SPlayerVideoStreamInfo &info)
 460 {
 461   boost::shared_ptr<IPlayer> player = GetInternal();
 462   if (player)
 463     player->GetVideoStreamInfo(info);
 464 }
 465
 466 void CApplicationPlayer::GetAudioStreamInfo(int index, SPlayerAudioStreamInfo &info)
 467 {
 468   boost::shared_ptr<IPlayer> player = GetInternal();
 469   if (player)
 470     player->GetAudioStreamInfo(index, info);
 471 }
 472
 473 bool CApplicationPlayer::OnAction(const CAction &action)
 474 {
 475   boost::shared_ptr<IPlayer> player = GetInternal();
 476   return (player && player->OnAction(action));
 477 }
 478
 479 bool CApplicationPlayer::Record(bool bOnOff)
 480 {
 481   boost::shared_ptr<IPlayer> player = GetInternal();
 482   return (player && player->Record(bOnOff));
 483 }
 484
 485 int  CApplicationPlayer::GetAudioStreamCount()
 486 {
 487   boost::shared_ptr<IPlayer> player = GetInternal();
 488   if (player)
 489     return player->GetAudioStreamCount();
 490   else
 491     return 0;
 492 }
 493
 494 void CApplicationPlayer::SetAudioStream(int iStream)
 495 {
 496   boost::shared_ptr<IPlayer> player = GetInternal();
 497   if (player)
 498   {
 499     player->SetAudioStream(iStream);
 500     m_iAudioStream = iStream;
 501     m_audioStreamUpdate.Set(1000);
 502   }
 503 }
 504
 505 void CApplicationPlayer::GetSubtitleStreamInfo(int index, SPlayerSubtitleStreamInfo &info)
 506 {
 507   boost::shared_ptr<IPlayer> player = GetInternal();
 508   if (player)
 509     player->GetSubtitleStreamInfo(index, info);
 510 }
 511
 512 void CApplicationPlayer::SetSubtitle(int iStream)
 513 {
 514   boost::shared_ptr<IPlayer> player = GetInternal();
 515   if (player)
 516   {
 517     player->SetSubtitle(iStream);
 518     m_iSubtitleStream = iStream;
 519     m_subtitleStreamUpdate.Set(1000);
 520   }
 521 }
 522
 523 void CApplicationPlayer::SetSubtitleVisible(bool bVisible)
 524 {
 525   boost::shared_ptr<IPlayer> player = GetInternal();
 526   if (player)
 527     player->SetSubtitleVisible(bVisible);
 528 }
 529
 530 int  CApplicationPlayer::AddSubtitle(const std::string& strSubPath)
 531 {
 532   boost::shared_ptr<IPlayer> player = GetInternal();
 533   if (player)
 534     return player->AddSubtitle(strSubPath);
 535   else
 536     return 0;
 537 }
 538
 539 void CApplicationPlayer::SetSubTitleDelay(float fValue)
 540 {
 541   boost::shared_ptr<IPlayer> player = GetInternal();
 542   if (player)
 543     player->SetSubTitleDelay(fValue);
 544 }
 545
 546 void CApplicationPlayer::SetAVDelay(float fValue)
 547 {
 548   boost::shared_ptr<IPlayer> player = GetInternal();
 549   if (player)
 550     player->SetAVDelay(fValue);
 551 }
 552
 553 void CApplicationPlayer::SetDynamicRangeCompression(long drc)
 554 {
 555   boost::shared_ptr<IPlayer> player = GetInternal();
 556   if (player)
 557     player->SetDynamicRangeCompression(drc);
 558 }
 559
 560 bool CApplicationPlayer::SwitchChannel(const PVR::CPVRChannel &channel)
 561 {
 562   boost::shared_ptr<IPlayer> player = GetInternal();
 563   return (player && player->SwitchChannel(channel));
 564 }
 565
 566 void CApplicationPlayer::LoadPage(int p, int sp, unsigned char* buffer)
 567 {
 568   boost::shared_ptr<IPlayer> player = GetInternal();
 569   if (player)
 570     player->LoadPage(p, sp, buffer);
 571 }
 572
 573 void CApplicationPlayer::GetAudioCapabilities(std::vector<int> &audioCaps)
 574 {
 575   boost::shared_ptr<IPlayer> player = GetInternal();
 576   if (player)
 577     player->GetAudioCapabilities(audioCaps);
 578 }
 579
 580 void CApplicationPlayer::GetSubtitleCapabilities(std::vector<int> &subCaps)
 581 {
 582   boost::shared_ptr<IPlayer> player = GetInternal();
 583   if (player)
 584     player->GetSubtitleCapabilities(subCaps);
 585 }
 586
 587 void CApplicationPlayer::GetAudioInfo(std::string& strAudioInfo)
 588 {
 589   boost::shared_ptr<IPlayer> player = GetInternal();
 590   if (player)
 591     player->GetAudioInfo(strAudioInfo);
 592 }
 593
 594 void CApplicationPlayer::GetVideoInfo(std::string& strVideoInfo)
 595 {
 596   boost::shared_ptr<IPlayer> player = GetInternal();
 597   if (player)
 598     player->GetVideoInfo(strVideoInfo);
 599 }
 600
 601 void CApplicationPlayer::GetGeneralInfo(std::string& strVideoInfo)
 602 {
 603   boost::shared_ptr<IPlayer> player = GetInternal();
 604   if (player)
 605     player->GetGeneralInfo(strVideoInfo);
 606 }
 607
 608 int  CApplicationPlayer::SeekChapter(int iChapter)
 609 {
 610   boost::shared_ptr<IPlayer> player = GetInternal();
 611   if (player)
 612     return player->SeekChapter(iChapter);
 613   else
 614     return 0;
 615 }
 616
 617 void CApplicationPlayer::GetRenderFeatures(std::vector<int> &renderFeatures)
 618 {
 619   boost::shared_ptr<IPlayer> player = GetInternal();
 620   if (player)
 621     player->GetRenderFeatures(renderFeatures);
 622 }
 623
 624 void CApplicationPlayer::GetDeinterlaceMethods(std::vector<int> &deinterlaceMethods)
 625 {
 626   boost::shared_ptr<IPlayer> player = GetInternal();
 627   if (player)
 628     player->GetDeinterlaceMethods(deinterlaceMethods);
 629 }
 630
 631 void CApplicationPlayer::GetDeinterlaceModes(std::vector<int> &deinterlaceModes)
 632 {
 633   boost::shared_ptr<IPlayer> player = GetInternal();
 634   if (player)
 635     player->GetDeinterlaceModes(deinterlaceModes);
 636 }
 637
 638 void CApplicationPlayer::GetScalingMethods(std::vector<int> &scalingMethods)
 639 {
 640   boost::shared_ptr<IPlayer> player = GetInternal();
 641   if (player)
 642     player->GetScalingMethods(scalingMethods);
 643 }
 644
 645 void CApplicationPlayer::SetPlaySpeed(int iSpeed, bool bApplicationMuted)
 646 {
 647   boost::shared_ptr<IPlayer> player = GetInternal();
 648   if (!player)
 649     return;
 650
 651   if (!IsPlayingAudio() && !IsPlayingVideo())
 652     return ;
 653   if (m_iPlaySpeed == iSpeed)
 654     return ;
 655   if (!CanSeek())
 656     return;
 657   if (IsPaused())
 658   {
 659     if (
 660       ((m_iPlaySpeed > 1) && (iSpeed > m_iPlaySpeed)) ||
 661       ((m_iPlaySpeed < -1) && (iSpeed < m_iPlaySpeed))
 662     )
 663     {
 664       iSpeed = m_iPlaySpeed; // from pause to ff/rw, do previous ff/rw speed
 665     }
 666     Pause();
 667   }
 668   m_iPlaySpeed = iSpeed;
 669
 670   ToFFRW(m_iPlaySpeed);
 671
 672   // if player has volume control, set it.
 673   if (ControlsVolume())
 674   {
 675     if (m_iPlaySpeed == 1)
 676     { // restore volume
 677       player->SetVolume(g_application.GetVolume(false));
 678     }
 679     else
 680     { // mute volume
 681       player->SetVolume(VOLUME_MINIMUM);
 682     }
 683     player->SetMute(bApplicationMuted);
 684   }
 685 }
 686
 687 int CApplicationPlayer::GetPlaySpeed() const
 688 {
 689   return m_iPlaySpeed;
 690 }