code.vuplus.com Git - vuplus_xbmc/blob - xbmc/Autorun.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 "system.h"
  22
  23 #ifdef HAS_DVD_DRIVE
  24
  25 #include "Autorun.h"
  26 #include "Application.h"
  27 #include "GUIPassword.h"
  28 #include "GUIUserMessages.h"
  29 #include "PlayListPlayer.h"
  30 #include "filesystem/StackDirectory.h"
  31 #include "filesystem/Directory.h"
  32 #include "filesystem/DirectoryFactory.h"
  33 #include "filesystem/File.h"
  34 #include "profiles/ProfilesManager.h"
  35 #include "settings/Settings.h"
  36 #include "playlists/PlayList.h"
  37 #include "guilib/GUIWindowManager.h"
  38 #include "guilib/LocalizeStrings.h"
  39 #include "storage/MediaManager.h"
  40 #include "video/VideoDatabase.h"
  41 #include "dialogs/GUIDialogYesNo.h"
  42 #include "utils/URIUtils.h"
  43 #include "utils/log.h"
  44 #ifdef HAS_CDDA_RIPPER
  45 #include "cdrip/CDDARipper.h"
  46 #endif
  47
  48 using namespace std;
  49 using namespace XFILE;
  50 using namespace PLAYLIST;
  51 using namespace MEDIA_DETECT;
  52
  53 CAutorun::CAutorun()
  54 {
  55   m_bEnable = true;
  56 }
  57
  58 CAutorun::~CAutorun()
  59 {}
  60
  61 void CAutorun::ExecuteAutorun(const CStdString& path, bool bypassSettings, bool ignoreplaying, bool startFromBeginning )
  62 {
  63   if ((!ignoreplaying && (g_application.m_pPlayer->IsPlayingAudio() || g_application.m_pPlayer->IsPlayingVideo() || g_windowManager.HasModalDialog())) || g_windowManager.GetActiveWindow() == WINDOW_LOGIN_SCREEN)
  64     return ;
  65
  66   CCdInfo* pInfo = g_mediaManager.GetCdInfo(path);
  67
  68   if ( pInfo == NULL )
  69     return ;
  70
  71   g_application.ResetScreenSaver();
  72   g_application.WakeUpScreenSaverAndDPMS();  // turn off the screensaver if it's active
  73 #ifdef HAS_CDDA_RIPPER
  74   if (CSettings::Get().GetInt("audiocds.autoaction") == AUTOCD_RIP &&
  75       pInfo->IsAudio(1) && !CProfilesManager::Get().GetCurrentProfile().musicLocked())
  76   {
  77     CCDDARipper::GetInstance().RipCD();
  78   }
  79   else
  80 #endif
  81   PlayDisc(path, bypassSettings, startFromBeginning);
  82 }
  83
  84 bool CAutorun::PlayDisc(const CStdString& path, bool bypassSettings, bool startFromBeginning)
  85 {
  86   if ( !bypassSettings && !CSettings::Get().GetInt("audiocds.autoaction") == AUTOCD_PLAY && !CSettings::Get().GetBool("dvds.autorun"))
  87     return false;
  88
  89   int nSize = g_playlistPlayer.GetPlaylist( PLAYLIST_MUSIC ).size();
  90   int nAddedToPlaylist = 0;
  91
  92   CStdString mediaPath;
  93
  94   CCdInfo* pInfo = g_mediaManager.GetCdInfo(path);
  95   if (pInfo == NULL)
  96     return false;
  97
  98   if (mediaPath.IsEmpty() && pInfo->IsAudio(1))
  99     mediaPath = "cdda://local/";
 100
 101   if (mediaPath.IsEmpty() && (pInfo->IsISOUDF(1) || pInfo->IsISOHFS(1) || pInfo->IsIso9660(1) || pInfo->IsIso9660Interactive(1)))
 102     mediaPath = "iso9660://";
 103
 104   if (mediaPath.IsEmpty())
 105     mediaPath = path;
 106
 107 #ifdef TARGET_WINDOWS
 108   if (mediaPath.IsEmpty() || mediaPath.CompareNoCase("iso9660://") == 0)
 109     mediaPath = g_mediaManager.TranslateDevicePath("");
 110 #endif
 111
 112   auto_ptr<IDirectory> pDir ( CDirectoryFactory::Create( mediaPath ));
 113   bool bPlaying = RunDisc(pDir.get(), mediaPath, nAddedToPlaylist, true, bypassSettings, startFromBeginning);
 114
 115   if ( !bPlaying && nAddedToPlaylist > 0 )
 116   {
 117     CGUIMessage msg( GUI_MSG_PLAYLIST_CHANGED, 0, 0 );
 118     g_windowManager.SendMessage( msg );
 119     g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_MUSIC);
 120     // Start playing the items we inserted
 121     return g_playlistPlayer.Play(nSize);
 122   }
 123
 124   return bPlaying;
 125 }
 126
 127 /**
 128  * This method tries to determine what type of disc is located in the given drive and starts to play the content appropriately.
 129  */
 130 bool CAutorun::RunDisc(IDirectory* pDir, const CStdString& strDrive, int& nAddedToPlaylist, bool bRoot, bool bypassSettings /* = false */, bool startFromBeginning /* = false */)
 131 {
 132   bool bPlaying(false);
 133   CFileItemList vecItems;
 134
 135   if ( !pDir->GetDirectory( strDrive, vecItems ) )
 136   {
 137     return false;
 138   }
 139
 140   // Sorting necessary for easier HDDVD handling
 141   vecItems.Sort(SortByLabel, SortOrderAscending);
 142
 143   bool bAllowVideo = true;
 144 //  bool bAllowPictures = true;
 145   bool bAllowMusic = true;
 146   if (!g_passwordManager.IsMasterLockUnlocked(false))
 147   {
 148     bAllowVideo = !CProfilesManager::Get().GetCurrentProfile().videoLocked();
 149 //    bAllowPictures = !CProfilesManager::Get().GetCurrentProfile().picturesLocked();
 150     bAllowMusic = !CProfilesManager::Get().GetCurrentProfile().musicLocked();
 151   }
 152
 153   // is this a root folder we have to check the content to determine a disc type
 154   if( bRoot )
 155   {
 156     CStdString hddvdname = "";
 157     CFileItemPtr phddvdItem;
 158
 159     // check root folders next, for normal structured dvd's
 160     for (int i = 0; i < vecItems.Size(); i++)
 161     {
 162       CFileItemPtr pItem = vecItems[i];
 163
 164       // is the current item a (non system) folder?
 165       if (pItem->m_bIsFolder && pItem->GetPath() != "." && pItem->GetPath() != "..")
 166       {
 167         CStdString name = pItem->GetPath();
 168         URIUtils::RemoveSlashAtEnd(name);
 169         name = URIUtils::GetFileName(name);
 170
 171         // Check if the current foldername indicates a DVD structure (name is "VIDEO_TS")
 172         if (name.Equals("VIDEO_TS") && bAllowVideo
 173         && (bypassSettings || CSettings::Get().GetBool("dvds.autorun")))
 174         {
 175           CStdString path = URIUtils::AddFileToFolder(pItem->GetPath(), "VIDEO_TS.IFO");
 176           if(!CFile::Exists(path))
 177             path = URIUtils::AddFileToFolder(pItem->GetPath(), "video_ts.ifo");
 178           CFileItem item(path, false);
 179           item.SetLabel(g_mediaManager.GetDiskLabel(strDrive));
 180           item.GetVideoInfoTag()->m_strFileNameAndPath = g_mediaManager.GetDiskUniqueId(strDrive);
 181
 182           if (!startFromBeginning && !item.GetVideoInfoTag()->m_strFileNameAndPath.IsEmpty())
 183             item.m_lStartOffset = STARTOFFSET_RESUME;
 184
 185           g_application.PlayFile(item, false);
 186           return true;
 187         }
 188
 189         // Check if the current foldername indicates a Blu-Ray structure (default is "BDMV").
 190         // A BR should also include an "AACS" folder for encryption, Sony-BRs can also include update folders for PS3 (PS3_UPDATE / PS3_VPRM).
 191         // ToDo: for the time beeing, the DVD autorun settings are used to determine if the BR should be started automatically.
 192         if (name.Equals("BDMV") && bAllowVideo
 193         && (bypassSettings || CSettings::Get().GetBool("dvds.autorun")))
 194         {
 195           CFileItem item(URIUtils::AddFileToFolder(pItem->GetPath(), "index.bdmv"), false);
 196           item.SetLabel(g_mediaManager.GetDiskLabel(strDrive));
 197           item.GetVideoInfoTag()->m_strFileNameAndPath = g_mediaManager.GetDiskUniqueId(strDrive);
 198
 199           if (!startFromBeginning && !item.GetVideoInfoTag()->m_strFileNameAndPath.IsEmpty())
 200             item.m_lStartOffset = STARTOFFSET_RESUME;
 201
 202           g_application.PlayFile(item, false);
 203           return true;
 204         }
 205
 206         // Check if the current foldername indicates a HD DVD structure (default is "HVDVD_TS").
 207         // Most HD DVD will also include an "ADV_OBJ" folder for advanced content. This folder should be handled first.
 208         // ToDo: for the time beeing, the DVD autorun settings are used to determine if the HD DVD should be started automatically.
 209         CFileItemList items, sitems;
 210
 211         // Advanced Content HD DVD (most discs?)
 212         if (name.Equals("ADV_OBJ"))
 213         {
 214           CLog::Log(LOGINFO,"HD DVD: Checking for playlist.");
 215           // find playlist file
 216           CDirectory::GetDirectory(pItem->GetPath(), items, "*.xpl");
 217           if (items.Size())
 218           {
 219             // HD DVD Standard says the highest numbered playlist has to be handled first.
 220             CLog::Log(LOGINFO,"HD DVD: Playlist found. Set filetypes to *.xpl for external player.");
 221             items.Sort(SortByLabel, SortOrderDescending);
 222             phddvdItem = pItem;
 223             hddvdname = URIUtils::GetFileName(items[0]->GetPath());
 224             CLog::Log(LOGINFO,"HD DVD: %s", items[0]->GetPath().c_str());
 225           }
 226         }
 227
 228         // Standard Content HD DVD (few discs?)
 229         if (name.Equals("HVDVD_TS") && bAllowVideo
 230         && (bypassSettings || CSettings::Get().GetBool("dvds.autorun")))
 231         {
 232           if (hddvdname == "")
 233           {
 234             CLog::Log(LOGINFO,"HD DVD: Checking for ifo.");
 235             // find Video Manager or Title Set Information
 236             CDirectory::GetDirectory(pItem->GetPath(), items, "HV*.ifo");
 237             if (items.Size())
 238             {
 239               // HD DVD Standard says the lowest numbered ifo has to be handled first.
 240               CLog::Log(LOGINFO,"HD DVD: IFO found. Set filename to HV* and filetypes to *.ifo for external player.");
 241               items.Sort(SortByLabel, SortOrderAscending);
 242               phddvdItem = pItem;
 243               hddvdname = URIUtils::GetFileName(items[0]->GetPath());
 244               CLog::Log(LOGINFO,"HD DVD: %s",items[0]->GetPath().c_str());
 245             }
 246           }
 247           // Find and sort *.evo files for internal playback.
 248           // While this algorithm works for all of my HD DVDs, it may fail on other discs. If there are very large extras which are
 249           // alphabetically before the main movie they will be sorted to the top of the playlist and get played first.
 250           CDirectory::GetDirectory(pItem->GetPath(), items, "*.evo");
 251           if (items.Size())
 252           {
 253             // Sort *.evo files in alphabetical order.
 254             items.Sort(SortByLabel, SortOrderAscending);
 255             int64_t asize = 0;
 256             int ecount = 0;
 257             // calculate average size of elements above 1gb
 258             for (int j = 0; j < items.Size(); j++)
 259               if (items[j]->m_dwSize > 1000000000)
 260               {
 261                 ecount++;
 262                 asize = asize + items[j]->m_dwSize;
 263               }
 264             asize = asize / ecount;
 265             // Put largest files in alphabetical order to top of new list.
 266             for (int j = 0; j < items.Size(); j++)
 267               if (items[j]->m_dwSize >= asize)
 268                 sitems.Add (items[j]);
 269             // Sort *.evo files by size.
 270             items.Sort(SortBySize, SortOrderDescending);
 271             // Add other files with descending size to bottom of new list.
 272             for (int j = 0; j < items.Size(); j++)
 273               if (items[j]->m_dwSize < asize)
 274                 sitems.Add (items[j]);
 275             // Replace list with optimized list.
 276             items.Clear();
 277             items.Copy (sitems);
 278             sitems.Clear();
 279           }
 280           if (hddvdname != "")
 281           {
 282             CFileItem item(URIUtils::AddFileToFolder(phddvdItem->GetPath(), hddvdname), false);
 283             item.SetLabel(g_mediaManager.GetDiskLabel(strDrive));
 284             item.GetVideoInfoTag()->m_strFileNameAndPath = g_mediaManager.GetDiskUniqueId(strDrive);
 285
 286             if (!startFromBeginning && !item.GetVideoInfoTag()->m_strFileNameAndPath.IsEmpty())
 287             item.m_lStartOffset = STARTOFFSET_RESUME;
 288
 289             // get playername
 290             CStdString hddvdplayer = CPlayerCoreFactory::Get().GetPlayerName(CPlayerCoreFactory::Get().GetDefaultPlayer(item));
 291
 292             // Single *.xpl or *.ifo files require an external player to handle playback.
 293             // If no matching rule was found, DVDPlayer will be default player.
 294             if (hddvdplayer != "DVDPlayer")
 295             {
 296               CLog::Log(LOGINFO,"HD DVD: External singlefile playback initiated: %s",hddvdname.c_str());
 297               g_application.PlayFile(item, false);
 298               return true;
 299             } else
 300               CLog::Log(LOGINFO,"HD DVD: No external player found. Fallback to internal one.");
 301           }
 302
 303           //  internal *.evo playback.
 304           CLog::Log(LOGINFO,"HD DVD: Internal multifile playback initiated.");
 305           g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
 306           g_playlistPlayer.SetShuffle (PLAYLIST_VIDEO, false);
 307           g_playlistPlayer.Add(PLAYLIST_VIDEO, items);
 308           g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
 309           g_playlistPlayer.Play(0);
 310           return true;
 311         }
 312
 313         // Video CDs can have multiple file formats. First we need to determine which one is used on the CD
 314         CStdString strExt;
 315         if (name.Equals("MPEGAV"))
 316           strExt = ".dat";
 317         if (name.Equals("MPEG2"))
 318           strExt = ".mpg";
 319
 320         // If a file format was extracted we are sure this is a VCD. Autoplay if settings indicate we should.
 321         if (!strExt.IsEmpty() && bAllowVideo
 322              && (bypassSettings || CSettings::Get().GetBool("dvds.autorun")))
 323         {
 324           CFileItemList items;
 325           CDirectory::GetDirectory(pItem->GetPath(), items, strExt);
 326           if (items.Size())
 327           {
 328             items.Sort(SortByLabel, SortOrderAscending);
 329             g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
 330             g_playlistPlayer.Add(PLAYLIST_VIDEO, items);
 331             g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
 332             g_playlistPlayer.Play(0);
 333             return true;
 334           }
 335         }
 336         /* Probably want this if/when we add some automedia action dialog...
 337         else if (pItem->GetPath().Find("PICTURES") != -1 && bAllowPictures
 338               && (bypassSettings))
 339         {
 340           bPlaying = true;
 341           CStdString strExec;
 342           strExec.Format("XBMC.RecursiveSlideShow(%s)", pItem->GetPath().c_str());
 343           CBuiltins::Execute(strExec);
 344           return true;
 345         }
 346         */
 347       }
 348     }
 349   }
 350
 351   // check video first
 352   if (!nAddedToPlaylist && !bPlaying && (bypassSettings || CSettings::Get().GetBool("dvds.autorun")))
 353   {
 354     // stack video files
 355     CFileItemList tempItems;
 356     tempItems.Append(vecItems);
 357     if (CSettings::Get().GetBool("myvideos.stackvideos"))
 358       tempItems.Stack();
 359     CFileItemList itemlist;
 360
 361     for (int i = 0; i < tempItems.Size(); i++)
 362     {
 363       CFileItemPtr pItem = tempItems[i];
 364       if (!pItem->m_bIsFolder && pItem->IsVideo())
 365       {
 366         bPlaying = true;
 367         if (pItem->IsStack())
 368         {
 369           // TODO: remove this once the app/player is capable of handling stacks immediately
 370           CStackDirectory dir;
 371           CFileItemList items;
 372           dir.GetDirectory(pItem->GetPath(), items);
 373           itemlist.Append(items);
 374         }
 375         else
 376           itemlist.Add(pItem);
 377       }
 378     }
 379     if (itemlist.Size())
 380     {
 381       if (!bAllowVideo)
 382       {
 383         if (!bypassSettings)
 384           return false;
 385
 386         if (g_windowManager.GetActiveWindow() != WINDOW_VIDEO_FILES)
 387           if (!g_passwordManager.IsMasterLockUnlocked(true))
 388             return false;
 389       }
 390       g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
 391       g_playlistPlayer.Add(PLAYLIST_VIDEO, itemlist);
 392       g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
 393       g_playlistPlayer.Play(0);
 394     }
 395   }
 396   // then music
 397   if (!bPlaying && (bypassSettings || CSettings::Get().GetInt("audiocds.autoaction") == AUTOCD_PLAY) && bAllowMusic)
 398   {
 399     for (int i = 0; i < vecItems.Size(); i++)
 400     {
 401       CFileItemPtr pItem = vecItems[i];
 402       if (!pItem->m_bIsFolder && pItem->IsAudio())
 403       {
 404         nAddedToPlaylist++;
 405         g_playlistPlayer.Add(PLAYLIST_MUSIC, pItem);
 406       }
 407     }
 408   }
 409   /* Probably want this if/when we add some automedia action dialog...
 410   // and finally pictures
 411   if (!nAddedToPlaylist && !bPlaying && bypassSettings && bAllowPictures)
 412   {
 413     for (int i = 0; i < vecItems.Size(); i++)
 414     {
 415       CFileItemPtr pItem = vecItems[i];
 416       if (!pItem->m_bIsFolder && pItem->IsPicture())
 417       {
 418         bPlaying = true;
 419         CStdString strExec;
 420         strExec.Format("XBMC.RecursiveSlideShow(%s)", strDrive.c_str());
 421         CBuiltins::Execute(strExec);
 422         break;
 423       }
 424     }
 425   }
 426   */
 427
 428   // check subdirs if we are not playing yet
 429   if (!bPlaying)
 430   {
 431     for (int i = 0; i < vecItems.Size(); i++)
 432     {
 433       CFileItemPtr  pItem = vecItems[i];
 434       if (pItem->m_bIsFolder)
 435       {
 436         if (pItem->GetPath() != "." && pItem->GetPath() != ".." )
 437         {
 438           if (RunDisc(pDir, pItem->GetPath(), nAddedToPlaylist, false, bypassSettings, startFromBeginning))
 439           {
 440             bPlaying = true;
 441             break;
 442           }
 443         }
 444       } // if (non system) folder
 445     } // for all items in directory
 446   } // if root folder
 447
 448   return bPlaying;
 449 }
 450
 451 void CAutorun::HandleAutorun()
 452 {
 453 #ifndef TARGET_WINDOWS
 454   if (!m_bEnable)
 455   {
 456     CDetectDVDMedia::m_evAutorun.Reset();
 457     return ;
 458   }
 459
 460   if (CDetectDVDMedia::m_evAutorun.WaitMSec(0))
 461   {
 462     ExecuteAutorun();
 463     CDetectDVDMedia::m_evAutorun.Reset();
 464   }
 465 #endif
 466 }
 467
 468 void CAutorun::Enable()
 469 {
 470   m_bEnable = true;
 471 }
 472
 473 void CAutorun::Disable()
 474 {
 475   m_bEnable = false;
 476 }
 477
 478 bool CAutorun::IsEnabled() const
 479 {
 480   return m_bEnable;
 481 }
 482
 483 bool CAutorun::PlayDiscAskResume(const CStdString& path)
 484 {
 485   return PlayDisc(path, true, !CanResumePlayDVD(path) || CGUIDialogYesNo::ShowAndGetInput(341, -1, -1, -1, 13404, 12021));
 486 }
 487
 488 bool CAutorun::CanResumePlayDVD(const CStdString& path)
 489 {
 490   CStdString strUniqueId = g_mediaManager.GetDiskUniqueId(path);
 491   if (!strUniqueId.IsEmpty())
 492   {
 493     CVideoDatabase dbs;
 494     dbs.Open();
 495     CBookmark bookmark;
 496     if (dbs.GetResumeBookMark(strUniqueId, bookmark))
 497       return true;
 498   }
 499   return false;
 500 }
 501
 502 void CAutorun::SettingOptionAudioCdActionsFiller(const CSetting *setting, std::vector< std::pair<std::string, int> > &list, int &current)
 503 {
 504   list.push_back(make_pair(g_localizeStrings.Get(16018), AUTOCD_NONE));
 505   list.push_back(make_pair(g_localizeStrings.Get(14098), AUTOCD_PLAY));
 506 #ifdef HAS_CDDA_RIPPER
 507   list.push_back(make_pair(g_localizeStrings.Get(14096), AUTOCD_RIP));
 508 #endif
 509 }
 510
 511 void CAutorun::SettingOptionAudioCdEncodersFiller(const CSetting *setting, std::vector< std::pair<std::string, int> > &list, int &current)
 512 {
 513 #ifdef HAVE_LIBMP3LAME
 514   list.push_back(make_pair(g_localizeStrings.Get(34000), CDDARIP_ENCODER_LAME));
 515 #endif
 516 #ifdef HAVE_LIBVORBISENC
 517   list.push_back(make_pair(g_localizeStrings.Get(34001), CDDARIP_ENCODER_VORBIS));
 518 #endif
 519   list.push_back(make_pair(g_localizeStrings.Get(34002), CDDARIP_ENCODER_WAV));
 520   list.push_back(make_pair(g_localizeStrings.Get(34005), CDDARIP_ENCODER_FLAC));
 521   list.push_back(make_pair(g_localizeStrings.Get(34006), CDDARIP_ENCODER_FFMPEG_M4A));
 522   list.push_back(make_pair(g_localizeStrings.Get(34007), CDDARIP_ENCODER_FFMPEG_WMA));
 523 }
 524
 525 #endif