void CLocalFilesSource::BindItems(CFileItemList& items)
{
// Perform post processing here
// Need to default video content to help with the UPnP case where we don't really know the content type
bool bDefaultVideo = false;
if( items.m_strPath.Equals("boxeedb://unresolvedVideoFiles") )
bDefaultVideo = true;
for (int i = 0 ; i < items.Size() ; i++)
{
CFileItemPtr pItem = items[i];
if (pItem->IsVideo() || bDefaultVideo)
{
pItem->SetProperty("IsVideo", true);
}
else if (pItem->IsAudio())
{
pItem->SetProperty("IsMusic", true);
}
else if (pItem->IsPicture())
{
pItem->SetProperty("IsPhotos", true);
}
else if (!pItem->m_bIsFolder)
{
items.Remove(i);
i--;
}
}
CBrowseWindowSource::BindItems(items);
}
bool CGUIWindowPictures::ShowPicture(int iItem, bool startSlideShow)
{
if ( iItem < 0 || iItem >= (int)m_vecItems->Size() ) return false;
CFileItemPtr pItem = m_vecItems->Get(iItem);
CStdString strPicture = pItem->GetPath();
#ifdef HAS_DVD_DRIVE
if (pItem->IsDVD())
return MEDIA_DETECT::CAutorun::PlayDiscAskResume(m_vecItems->Get(iItem)->GetPath());
#endif
if (pItem->m_bIsShareOrDrive)
return false;
CGUIWindowSlideShow *pSlideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!pSlideShow)
return false;
if (g_application.m_pPlayer->IsPlayingVideo())
g_application.StopPlaying();
pSlideShow->Reset();
for (int i = 0; i < (int)m_vecItems->Size();++i)
{
CFileItemPtr pItem = m_vecItems->Get(i);
if (!pItem->m_bIsFolder && !(URIUtils::IsRAR(pItem->GetPath()) ||
URIUtils::IsZIP(pItem->GetPath())) && (pItem->IsPicture() || (
CSettings::Get().GetBool("pictures.showvideos") &&
pItem->IsVideo())))
{
pSlideShow->Add(pItem.get());
}
}
if (pSlideShow->NumSlides() == 0)
return false;
pSlideShow->Select(strPicture);
if (startSlideShow)
pSlideShow->StartSlideShow();
else
{
CVariant param;
param["player"]["speed"] = 1;
param["player"]["playerid"] = PLAYLIST_PICTURE;
ANNOUNCEMENT::CAnnouncementManager::Get().Announce(ANNOUNCEMENT::Player, "xbmc", "OnPlay", pSlideShow->GetCurrentSlide(), param);
}
m_slideShowStarted = true;
g_windowManager.ActivateWindow(WINDOW_SLIDESHOW);
return true;
}
INFO_RET CMusicInfoScanner::ScanTags(const CFileItemList& items, CFileItemList& scannedItems)
{
std::vector<std::string> regexps = g_advancedSettings.m_audioExcludeFromScanRegExps;
for (int i = 0; i < items.Size(); ++i)
{
if (m_bStop)
return INFO_CANCELLED;
CFileItemPtr pItem = items[i];
if (CUtil::ExcludeFileOrFolder(pItem->GetPath(), regexps))
continue;
if (pItem->m_bIsFolder || pItem->IsPlayList() || pItem->IsPicture() || pItem->IsLyrics())
continue;
m_currentItem++;
CMusicInfoTag& tag = *pItem->GetMusicInfoTag();
if (!tag.Loaded())
{
std::unique_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(*pItem));
if (NULL != pLoader.get())
pLoader->Load(pItem->GetPath(), tag);
}
if (m_handle && m_itemCount>0)
m_handle->SetPercentage(m_currentItem / (float)m_itemCount * 100);
if (!tag.Loaded() && !pItem->HasCueDocument())
{
CLog::Log(LOGDEBUG, "%s - No tag found for: %s", __FUNCTION__, pItem->GetPath().c_str());
continue;
}
else
{
if (!tag.GetCueSheet().empty())
pItem->LoadEmbeddedCue();
}
if (pItem->HasCueDocument())
pItem->LoadTracksFromCueDocument(scannedItems);
else
scannedItems.Add(pItem);
}
return INFO_ADDED;
}
bool CGUIWindowPictures::ShowPicture(int iItem, bool startSlideShow)
{
if ( iItem < 0 || iItem >= (int)m_vecItems->Size() ) return false;
CFileItemPtr pItem = m_vecItems->Get(iItem);
CStdString strPicture = pItem->GetPath();
#ifdef HAS_DVD_DRIVE
if (pItem->IsDVD())
return MEDIA_DETECT::CAutorun::PlayDiscAskResume(m_vecItems->Get(iItem)->GetPath());
#endif
if (pItem->m_bIsShareOrDrive)
return false;
CGUIWindowSlideShow *pSlideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!pSlideShow)
return false;
if (g_application.IsPlayingVideo())
g_application.StopPlaying();
pSlideShow->Reset();
for (int i = 0; i < (int)m_vecItems->Size();++i)
{
CFileItemPtr pItem = m_vecItems->Get(i);
if (!pItem->m_bIsFolder && !(URIUtils::IsRAR(pItem->GetPath()) ||
URIUtils::IsZIP(pItem->GetPath())) && (pItem->IsPicture() || (
g_guiSettings.GetBool("pictures.showvideos") &&
pItem->IsVideo())))
{
pSlideShow->Add(pItem.get());
}
}
if (pSlideShow->NumSlides() == 0)
return false;
pSlideShow->Select(strPicture);
if (startSlideShow)
pSlideShow->StartSlideShow(false);
m_slideShowStarted = true;
g_windowManager.ActivateWindow(WINDOW_SLIDESHOW);
return true;
}
void CGUIMultiImage::LoadDirectory()
{
// Load any images from our texture bundle first
m_files.clear();
// don't load any images if our path is empty
if (m_currentPath.IsEmpty()) return;
// check to see if we have a single image or a folder of images
CFileItem item(m_currentPath, false);
if (item.IsPicture())
{
m_files.push_back(m_currentPath);
}
else
{ // folder of images
g_TextureManager.GetBundledTexturesFromPath(m_currentPath, m_files);
// Load in our images from the directory specified
// m_currentPath is relative (as are all skin paths)
CStdString realPath = g_TextureManager.GetTexturePath(m_currentPath, true);
if (realPath.IsEmpty() && m_files.empty())
return;
URIUtils::AddSlashAtEnd(realPath);
CFileItemList items;
CDirectory::GetDirectory(realPath, items);
for (int i=0; i < items.Size(); i++)
{
CFileItemPtr pItem = items[i];
if (pItem->IsPicture())
m_files.push_back(pItem->GetPath());
}
}
// Randomize or sort our images if necessary
if (m_randomized)
random_shuffle(m_files.begin(), m_files.end());
else
sort(m_files.begin(), m_files.end());
// flag as loaded - no point in constantly reloading them
m_directoryLoaded = true;
m_imageTimer.StartZero();
}
/*----------------------------------------------------------------------
| CUPnPRenderer::PlayMedia
+---------------------------------------------------------------------*/
NPT_Result
CUPnPRenderer::PlayMedia(const NPT_String& uri, const NPT_String& meta, PLT_Action* action)
{
PLT_Service* service;
NPT_CHECK_SEVERE(FindServiceByType("urn:schemas-upnp-org:service:AVTransport:1", service));
{ NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "TRANSITIONING");
service->SetStateVariable("TransportStatus", "OK");
}
CFileItemPtr item = GetFileItem(uri, meta);
if (!item) {
return NPT_FAILURE;
}
#if 0
if (item->IsPicture()) {
CApplicationMessenger::Get().PictureShow(item->GetPath());
} else {
CApplicationMessenger::Get().MediaPlay(*item);
}
if (g_application.m_pPlayer->IsPlaying() || g_windowManager.GetActiveWindow() == WINDOW_SLIDESHOW) {
NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "PLAYING");
service->SetStateVariable("TransportStatus", "OK");
service->SetStateVariable("AVTransportURI", uri);
service->SetStateVariable("AVTransportURIMetaData", meta);
} else {
NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "STOPPED");
service->SetStateVariable("TransportStatus", "ERROR_OCCURRED");
}
service->SetStateVariable("NextAVTransportURI", "");
service->SetStateVariable("NextAVTransportURIMetaData", "");
if (action) {
NPT_CHECK_SEVERE(action->SetArgumentsOutFromStateVariable());
}
#endif
return NPT_SUCCESS;
}
/// \brief Retrieve tag information for \e m_vecItems
void CGUIWindowMusicBase::RetrieveMusicInfo()
{
unsigned int startTick = XbmcThreads::SystemClockMillis();
OnRetrieveMusicInfo(*m_vecItems);
// \todo Scan for multitrack items here...
vector<string> itemsForRemove;
CFileItemList itemsForAdd;
for (int i = 0; i < m_vecItems->Size(); ++i)
{
CFileItemPtr pItem = (*m_vecItems)[i];
if (pItem->m_bIsFolder || pItem->IsPlayList() || pItem->IsPicture() || pItem->IsLyrics())
continue;
CMusicInfoTag& tag = *pItem->GetMusicInfoTag();
if (tag.Loaded() && !tag.GetCueSheet().empty())
pItem->LoadEmbeddedCue();
if (pItem->HasCueDocument()
&& pItem->LoadTracksFromCueDocument(itemsForAdd))
{
itemsForRemove.push_back(pItem->GetPath());
}
}
for (size_t i = 0; i < itemsForRemove.size(); ++i)
{
for (int j = 0; j < m_vecItems->Size(); ++j)
{
if ((*m_vecItems)[j]->GetPath() == itemsForRemove[i])
{
m_vecItems->Remove(j);
break;
}
}
}
m_vecItems->Append(itemsForAdd);
CLog::Log(LOGDEBUG, "RetrieveMusicInfo() took %u msec",
XbmcThreads::SystemClockMillis() - startTick);
}
bool CFileItemHandler::FillFileItemList(const CVariant ¶meterObject, CFileItemList &list)
{
CAudioLibrary::FillFileItemList(parameterObject, list);
CVideoLibrary::FillFileItemList(parameterObject, list);
CFileOperations::FillFileItemList(parameterObject, list);
CStdString file = parameterObject["file"].asString();
if (!file.empty() && (URIUtils::IsURL(file) || (CFile::Exists(file) && !CDirectory::Exists(file))))
{
bool added = false;
for (int index = 0; index < list.Size(); index++)
{
if (list[index]->GetPath() == file)
{
added = true;
break;
}
}
if (!added)
{
CFileItemPtr item = CFileItemPtr(new CFileItem(file, false));
if (item->IsPicture())
{
CPictureInfoTag picture;
picture.Load(item->GetPath());
*item->GetPictureInfoTag() = picture;
}
if (item->GetLabel().empty())
{
item->SetLabel(CUtil::GetTitleFromPath(file, false));
if (item->GetLabel().empty())
item->SetLabel(URIUtils::GetFileName(file));
}
list.Add(item);
}
}
return (list.Size() > 0);
}
void CGUIWindowPictures::GetContextButtons(int itemNumber, CContextButtons &buttons)
{
CFileItemPtr item;
if (itemNumber >= 0 && itemNumber < m_vecItems->Size())
item = m_vecItems->Get(itemNumber);
if (item)
{
if ( m_vecItems->IsVirtualDirectoryRoot() || m_vecItems->GetPath() == "sources://pictures/" )
{
CGUIDialogContextMenu::GetContextButtons("pictures", item, buttons);
}
else
{
if (item)
{
if (!(item->m_bIsFolder || item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR() || item->IsScript()))
{
if (item->IsPicture())
buttons.Add(CONTEXT_BUTTON_INFO, 13406); // picture info
buttons.Add(CONTEXT_BUTTON_VIEW_SLIDESHOW, item->m_bIsFolder ? 13317 : 13422); // View Slideshow
}
if (item->m_bIsFolder)
buttons.Add(CONTEXT_BUTTON_RECURSIVE_SLIDESHOW, 13318); // Recursive Slideshow
if (!m_thumbLoader.IsLoading())
buttons.Add(CONTEXT_BUTTON_REFRESH_THUMBS, 13315); // Create Thumbnails
if (CServiceBroker::GetSettings().GetBool(CSettings::SETTING_FILELISTS_ALLOWFILEDELETION) && !item->IsReadOnly())
{
buttons.Add(CONTEXT_BUTTON_DELETE, 117);
buttons.Add(CONTEXT_BUTTON_RENAME, 118);
}
}
if (!item->IsPlugin() && !item->IsScript() && !m_vecItems->IsPlugin())
buttons.Add(CONTEXT_BUTTON_SWITCH_MEDIA, 523);
}
}
CGUIMediaWindow::GetContextButtons(itemNumber, buttons);
}
void CGUIWindowPictures::LoadPlayList(const CStdString& strPlayList)
{
CLog::Log(LOGDEBUG,"CGUIWindowPictures::LoadPlayList()... converting playlist into slideshow: %s", strPlayList.c_str());
auto_ptr<CPlayList> pPlayList (CPlayListFactory::Create(strPlayList));
if ( NULL != pPlayList.get())
{
if (!pPlayList->Load(strPlayList))
{
CGUIDialogOK::ShowAndGetInput(6, 0, 477, 0);
return ; //hmmm unable to load playlist?
}
}
CPlayList playlist = *pPlayList;
if (playlist.size() > 0)
{
// set up slideshow
CGUIWindowSlideShow *pSlideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!pSlideShow)
return;
if (g_application.m_pPlayer->IsPlayingVideo())
g_application.StopPlaying();
// convert playlist items into slideshow items
pSlideShow->Reset();
for (int i = 0; i < (int)playlist.size(); ++i)
{
CFileItemPtr pItem = playlist[i];
//CLog::Log(LOGDEBUG,"-- playlist item: %s", pItem->GetPath().c_str());
if (pItem->IsPicture() && !(pItem->IsZIP() || pItem->IsRAR() || pItem->IsCBZ() || pItem->IsCBR()))
pSlideShow->Add(pItem.get());
}
// start slideshow if there are items
pSlideShow->StartSlideShow();
if (pSlideShow->NumSlides())
g_windowManager.ActivateWindow(WINDOW_SLIDESHOW);
}
}
/*----------------------------------------------------------------------
| CUPnPRenderer::PlayMedia
+---------------------------------------------------------------------*/
NPT_Result
CUPnPRenderer::PlayMedia(const NPT_String& uri, const NPT_String& meta, PLT_Action* action)
{
PLT_Service* service;
NPT_CHECK_SEVERE(FindServiceByType("urn:schemas-upnp-org:service:AVTransport:1", service));
{ NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "TRANSITIONING");
service->SetStateVariable("TransportStatus", "OK");
}
CFileItemPtr item = GetFileItem(uri, meta);
if (!item) {
return NPT_FAILURE;
}
if (item->IsPicture()) {
CApplicationMessenger::GetInstance().PostMsg(TMSG_PICTURE_SHOW, -1, -1, nullptr, item->GetPath());
} else {
CFileItemList *l = new CFileItemList; //don't delete,
l->Add(std::make_shared<CFileItem>(*item));
CApplicationMessenger::GetInstance().PostMsg(TMSG_MEDIA_PLAY, -1, -1, static_cast<void*>(l));
}
// just return success because the play actions are asynchronous
NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "PLAYING");
service->SetStateVariable("TransportStatus", "OK");
service->SetStateVariable("AVTransportURI", uri);
service->SetStateVariable("AVTransportURIMetaData", meta);
service->SetStateVariable("NextAVTransportURI", "");
service->SetStateVariable("NextAVTransportURIMetaData", "");
if (action) {
NPT_CHECK_SEVERE(action->SetArgumentsOutFromStateVariable());
}
return NPT_SUCCESS;
}
void CGUIWindowPictures::LoadPlayList(const std::string& strPlayList)
{
CLog::Log(LOGDEBUG,"CGUIWindowPictures::LoadPlayList()... converting playlist into slideshow: %s", strPlayList.c_str());
std::unique_ptr<CPlayList> pPlayList (CPlayListFactory::Create(strPlayList));
if ( NULL != pPlayList.get())
{
if (!pPlayList->Load(strPlayList))
{
HELPERS::ShowOKDialogText(CVariant{6}, CVariant{477});
return ; //hmmm unable to load playlist?
}
}
CPlayList playlist = *pPlayList;
if (playlist.size() > 0)
{
// set up slideshow
CGUIWindowSlideShow *pSlideShow = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIWindowSlideShow>(WINDOW_SLIDESHOW);
if (!pSlideShow)
return;
if (g_application.GetAppPlayer().IsPlayingVideo())
g_application.StopPlaying();
// convert playlist items into slideshow items
pSlideShow->Reset();
for (int i = 0; i < (int)playlist.size(); ++i)
{
CFileItemPtr pItem = playlist[i];
//CLog::Log(LOGDEBUG,"-- playlist item: %s", pItem->GetPath().c_str());
if (pItem->IsPicture() && !(pItem->IsZIP() || pItem->IsRAR() || pItem->IsCBZ() || pItem->IsCBR()))
pSlideShow->Add(pItem.get());
}
// start slideshow if there are items
pSlideShow->StartSlideShow();
if (pSlideShow->NumSlides())
CServiceBroker::GetGUI()->GetWindowManager().ActivateWindow(WINDOW_SLIDESHOW);
}
}
void CGUIWindowPictures::OnInfo(int itemNumber)
{
CFileItemPtr item = (itemNumber >= 0 && itemNumber < m_vecItems->Size()) ? m_vecItems->Get(itemNumber) : CFileItemPtr();
if (!item)
return;
if (!m_vecItems->IsPlugin() && (item->IsPlugin() || item->IsScript()))
{
CGUIDialogAddonInfo::ShowForItem(item);
return;
}
if (item->m_bIsFolder || item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR() || !item->IsPicture())
return;
CGUIDialogPictureInfo *pictureInfo = (CGUIDialogPictureInfo *)g_windowManager.GetWindow(WINDOW_DIALOG_PICTURE_INFO);
if (pictureInfo)
{
pictureInfo->SetPicture(item.get());
pictureInfo->DoModal();
}
}
int CMusicInfoScanner::RetrieveMusicInfo(CFileItemList& items, const CStdString& strDirectory)
{
CSongMap songsMap;
// get all information for all files in current directory from database, and remove them
if (m_musicDatabase.RemoveSongsFromPath(strDirectory, songsMap))
m_needsCleanup = true;
VECSONGS songsToAdd;
CStdStringArray regexps = g_advancedSettings.m_audioExcludeFromScanRegExps;
// for every file found, but skip folder
for (int i = 0; i < items.Size(); ++i)
{
CFileItemPtr pItem = items[i];
CStdString strExtension;
URIUtils::GetExtension(pItem->GetPath(), strExtension);
if (m_bStop)
return 0;
// Discard all excluded files defined by m_musicExcludeRegExps
if (CUtil::ExcludeFileOrFolder(pItem->GetPath(), regexps))
continue;
// dont try reading id3tags for folders, playlists or shoutcast streams
if (!pItem->m_bIsFolder && !pItem->IsPlayList() && !pItem->IsPicture() && !pItem->IsLyrics() )
{
m_currentItem++;
// CLog::Log(LOGDEBUG, "%s - Reading tag for: %s", __FUNCTION__, pItem->GetPath().c_str());
// grab info from the song
CSong *dbSong = songsMap.Find(pItem->GetPath());
CMusicInfoTag& tag = *pItem->GetMusicInfoTag();
if (!tag.Loaded() )
{ // read the tag from a file
auto_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(pItem->GetPath()));
if (NULL != pLoader.get())
pLoader->Load(pItem->GetPath(), tag);
}
// if we have the itemcount, update our
// dialog with the progress we made
if (m_handle && m_itemCount>0)
m_handle->SetPercentage(m_currentItem/(float)m_itemCount*100);
if (tag.Loaded())
{
CSong song(tag);
// ensure our song has a valid filename or else it will assert in AddSong()
if (song.strFileName.IsEmpty())
{
// copy filename from path in case UPnP or other tag loaders didn't specify one (FIXME?)
song.strFileName = pItem->GetPath();
// if we still don't have a valid filename, skip the song
if (song.strFileName.IsEmpty())
{
// this shouldn't ideally happen!
CLog::Log(LOGERROR, "Skipping song since it doesn't seem to have a filename");
continue;
}
}
song.iStartOffset = pItem->m_lStartOffset;
song.iEndOffset = pItem->m_lEndOffset;
song.strThumb = pItem->GetUserMusicThumb(true);
if (dbSong)
{ // keep the db-only fields intact on rescan...
song.iTimesPlayed = dbSong->iTimesPlayed;
song.lastPlayed = dbSong->lastPlayed;
song.iKaraokeNumber = dbSong->iKaraokeNumber;
if (song.rating == '0') song.rating = dbSong->rating;
if (song.strThumb.empty())
song.strThumb = dbSong->strThumb;
}
songsToAdd.push_back(song);
// CLog::Log(LOGDEBUG, "%s - Tag loaded for: %s", __FUNCTION__, pItem->GetPath().c_str());
}
else
CLog::Log(LOGDEBUG, "%s - No tag found for: %s", __FUNCTION__, pItem->GetPath().c_str());
}
}
VECALBUMS albums;
CategoriseAlbums(songsToAdd, albums);
FindArtForAlbums(albums, items.GetPath());
// finally, add these to the database
m_musicDatabase.BeginTransaction();
int numAdded = 0;
set<int> albumsToScan;
set<int> artistsToScan;
for (VECALBUMS::iterator i = albums.begin(); i != albums.end(); ++i)
{
vector<int> songIDs;
int idAlbum = m_musicDatabase.AddAlbum(*i, songIDs);
numAdded += i->songs.size();
if (m_bStop)
{
m_musicDatabase.RollbackTransaction();
return numAdded;
}
// Build the artist & album sets
albumsToScan.insert(idAlbum);
for (vector<int>::iterator j = songIDs.begin(); j != songIDs.end(); ++j)
{
vector<int> songArtists;
m_musicDatabase.GetArtistsBySong(*j, false, songArtists);
artistsToScan.insert(songArtists.begin(), songArtists.end());
}
std::vector<int> albumArtists;
m_musicDatabase.GetArtistsByAlbum(idAlbum, false, albumArtists);
artistsToScan.insert(albumArtists.begin(), albumArtists.end());
}
m_musicDatabase.CommitTransaction();
// Download info & artwork
bool bCanceled;
for (set<int>::iterator it = artistsToScan.begin(); it != artistsToScan.end(); ++it)
{
bCanceled = false;
if (find(m_artistsScanned.begin(),m_artistsScanned.end(), *it) == m_artistsScanned.end())
{
CStdString strArtist = m_musicDatabase.GetArtistById(*it);
m_artistsScanned.push_back(*it);
if (!m_bStop && (m_flags & SCAN_ONLINE))
{
CStdString strPath;
strPath.Format("musicdb://2/%u/", *it);
if (!DownloadArtistInfo(strPath, strArtist, bCanceled)) // assume we want to retry
m_artistsScanned.pop_back();
}
else
{
map<string, string> artwork = GetArtistArtwork(*it);
m_musicDatabase.SetArtForItem(*it, "artist", artwork);
}
}
}
if (m_flags & SCAN_ONLINE)
{
for (set<int>::iterator it = albumsToScan.begin(); it != albumsToScan.end(); ++it)
{
if (m_bStop)
return songsToAdd.size();
CStdString strPath;
strPath.Format("musicdb://3/%u/",*it);
CAlbum album;
m_musicDatabase.GetAlbumInfo(*it, album, NULL);
bCanceled = false;
if (find(m_albumsScanned.begin(), m_albumsScanned.end(), *it) == m_albumsScanned.end())
{
CMusicAlbumInfo albumInfo;
if (DownloadAlbumInfo(strPath, StringUtils::Join(album.artist, g_advancedSettings.m_musicItemSeparator), album.strAlbum, bCanceled, albumInfo))
m_albumsScanned.push_back(*it);
}
}
}
if (m_handle)
m_handle->SetTitle(g_localizeStrings.Get(505));
return songsToAdd.size();
}
int CMusicInfoScanner::RetrieveMusicInfo(CFileItemList& items, const CStdString& strDirectory)
{
CSongMap songsMap;
// get all information for all files in current directory from database, and remove them
if (m_musicDatabase.RemoveSongsFromPath(strDirectory, songsMap))
m_needsCleanup = true;
VECSONGS songsToAdd;
CStdStringArray regexps = g_advancedSettings.m_audioExcludeFromScanRegExps;
// for every file found, but skip folder
for (int i = 0; i < items.Size(); ++i)
{
CFileItemPtr pItem = items[i];
CStdString strExtension;
URIUtils::GetExtension(pItem->GetPath(), strExtension);
if (m_bStop)
return 0;
// Discard all excluded files defined by m_musicExcludeRegExps
if (CUtil::ExcludeFileOrFolder(pItem->GetPath(), regexps))
continue;
// dont try reading id3tags for folders, playlists or shoutcast streams
if (!pItem->m_bIsFolder && !pItem->IsPlayList() && !pItem->IsPicture() && !pItem->IsLyrics() )
{
m_currentItem++;
// CLog::Log(LOGDEBUG, "%s - Reading tag for: %s", __FUNCTION__, pItem->GetPath().c_str());
// grab info from the song
CSong *dbSong = songsMap.Find(pItem->GetPath());
CMusicInfoTag& tag = *pItem->GetMusicInfoTag();
if (!tag.Loaded() )
{ // read the tag from a file
auto_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(pItem->GetPath()));
if (NULL != pLoader.get())
pLoader->Load(pItem->GetPath(), tag);
}
// if we have the itemcount, notify our
// observer with the progress we made
if (m_pObserver && m_itemCount>0)
m_pObserver->OnSetProgress(m_currentItem, m_itemCount);
if (tag.Loaded())
{
CSong song(tag);
// ensure our song has a valid filename or else it will assert in AddSong()
if (song.strFileName.IsEmpty())
{
// copy filename from path in case UPnP or other tag loaders didn't specify one (FIXME?)
song.strFileName = pItem->GetPath();
// if we still don't have a valid filename, skip the song
if (song.strFileName.IsEmpty())
{
// this shouldn't ideally happen!
CLog::Log(LOGERROR, "Skipping song since it doesn't seem to have a filename");
continue;
}
}
song.iStartOffset = pItem->m_lStartOffset;
song.iEndOffset = pItem->m_lEndOffset;
if (dbSong)
{ // keep the db-only fields intact on rescan...
song.iTimesPlayed = dbSong->iTimesPlayed;
song.lastPlayed = dbSong->lastPlayed;
song.iKaraokeNumber = dbSong->iKaraokeNumber;
if (song.rating == '0') song.rating = dbSong->rating;
}
pItem->SetMusicThumb();
song.strThumb = pItem->GetThumbnailImage();
songsToAdd.push_back(song);
// CLog::Log(LOGDEBUG, "%s - Tag loaded for: %s", __FUNCTION__, pItem->GetPath().c_str());
}
else
CLog::Log(LOGDEBUG, "%s - No tag found for: %s", __FUNCTION__, pItem->GetPath().c_str());
}
}
CheckForVariousArtists(songsToAdd);
if (!items.HasThumbnail())
UpdateFolderThumb(songsToAdd, items.GetPath());
// finally, add these to the database
set<CStdString> artistsToScan;
set< pair<CStdString, CStdString> > albumsToScan;
m_musicDatabase.BeginTransaction();
for (unsigned int i = 0; i < songsToAdd.size(); ++i)
{
if (m_bStop)
{
m_musicDatabase.RollbackTransaction();
return i;
}
CSong &song = songsToAdd[i];
m_musicDatabase.AddSong(song, false);
artistsToScan.insert(song.strArtist);
albumsToScan.insert(make_pair(song.strAlbum, song.strArtist));
}
m_musicDatabase.CommitTransaction();
bool bCanceled;
for (set<CStdString>::iterator i = artistsToScan.begin(); i != artistsToScan.end(); ++i)
{
bCanceled = false;
long iArtist = m_musicDatabase.GetArtistByName(*i);
if (find(m_artistsScanned.begin(),m_artistsScanned.end(),iArtist) == m_artistsScanned.end())
{
m_artistsScanned.push_back(iArtist);
if (!m_bStop && g_guiSettings.GetBool("musiclibrary.downloadinfo"))
{
CStdString strPath;
strPath.Format("musicdb://2/%u/",iArtist);
if (!DownloadArtistInfo(strPath,*i, bCanceled)) // assume we want to retry
m_artistsScanned.pop_back();
}
else
GetArtistArtwork(iArtist, *i);
}
}
if (g_guiSettings.GetBool("musiclibrary.downloadinfo"))
{
for (set< pair<CStdString, CStdString> >::iterator i = albumsToScan.begin(); i != albumsToScan.end(); ++i)
{
if (m_bStop)
return songsToAdd.size();
long iAlbum = m_musicDatabase.GetAlbumByName(i->first, i->second);
CStdString strPath;
strPath.Format("musicdb://3/%u/",iAlbum);
bCanceled = false;
if (find(m_albumsScanned.begin(), m_albumsScanned.end(), iAlbum) == m_albumsScanned.end())
{
CMusicAlbumInfo albumInfo;
if (DownloadAlbumInfo(strPath, i->second, i->first, bCanceled, albumInfo))
m_albumsScanned.push_back(iAlbum);
}
}
}
if (m_pObserver)
m_pObserver->OnStateChanged(READING_MUSIC_INFO);
return songsToAdd.size();
}
bool CAutorun::RunDisc(IDirectory* pDir, const CStdString& strDrive, int& nAddedToPlaylist, bool bRoot, bool bypassSettings /* = false */)
{
bool bPlaying(false);
CFileItemList vecItems;
char szSlash = '\\';
if (strDrive.Find("iso9660") != -1) szSlash = '/';
if ( !pDir->GetDirectory( strDrive, vecItems ) )
{
return false;
}
bool bAllowVideo = true;
bool bAllowPictures = true;
bool bAllowMusic = true;
if (!g_passwordManager.IsMasterLockUnlocked(false))
{
bAllowVideo = !g_settings.m_vecProfiles[g_settings.m_iLastLoadedProfileIndex].videoLocked();
bAllowPictures = !g_settings.m_vecProfiles[g_settings.m_iLastLoadedProfileIndex].picturesLocked();
bAllowMusic = !g_settings.m_vecProfiles[g_settings.m_iLastLoadedProfileIndex].musicLocked();
}
if( bRoot )
{
// check root folders first, for normal structured dvd's
for (int i = 0; i < vecItems.Size(); i++)
{
CFileItemPtr pItem = vecItems[i];
if (pItem->m_bIsFolder && pItem->m_strPath != "." && pItem->m_strPath != "..")
{
if (pItem->m_strPath.Find( "VIDEO_TS" ) != -1 && bAllowVideo
&& (bypassSettings || g_guiSettings.GetBool("autorun.dvd")))
{
CUtil::PlayDVD();
bPlaying = true;
return true;
}
else if (pItem->m_strPath.Find("MPEGAV") != -1 && bAllowVideo
&& (bypassSettings || g_guiSettings.GetBool("autorun.vcd")))
{
CFileItemList items;
CDirectory::GetDirectory(pItem->m_strPath, items, ".dat");
if (items.Size())
{
items.Sort(SORT_METHOD_LABEL, SORT_ORDER_ASC);
g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Add(PLAYLIST_VIDEO, items);
g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Play(0);
bPlaying = true;
return true;
}
}
else if (pItem->m_strPath.Find("MPEG2") != -1 && bAllowVideo
&& (bypassSettings || g_guiSettings.GetBool("autorun.vcd")))
{
CFileItemList items;
CDirectory::GetDirectory(pItem->m_strPath, items, ".mpg");
if (items.Size())
{
items.Sort(SORT_METHOD_LABEL, SORT_ORDER_ASC);
g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Add(PLAYLIST_VIDEO, items);
g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Play(0);
bPlaying = true;
return true;
}
}
else if (pItem->m_strPath.Find("PICTURES") != -1 && bAllowPictures
&& (bypassSettings || g_guiSettings.GetBool("autorun.pictures")))
{
bPlaying = true;
CStdString strExec;
strExec.Format("XBMC.RecursiveSlideShow(%s)", pItem->m_strPath.c_str());
CBuiltins::Execute(strExec);
return true;
}
}
}
}
// check video first
if (!nAddedToPlaylist && !bPlaying && (bypassSettings || g_guiSettings.GetBool("autorun.video")))
{
// stack video files
CFileItemList tempItems;
tempItems.Append(vecItems);
if (g_stSettings.m_iMyVideoStack != STACK_NONE)
tempItems.Stack();
CFileItemList itemlist;
for (int i = 0; i < tempItems.Size(); i++)
{
CFileItemPtr pItem = tempItems[i];
if (!pItem->m_bIsFolder && pItem->IsVideo())
{
bPlaying = true;
if (pItem->IsStack())
{
// TODO: remove this once the app/player is capable of handling stacks immediately
CStackDirectory dir;
CFileItemList items;
dir.GetDirectory(pItem->m_strPath, items);
itemlist.Append(items);
}
else
itemlist.Add(pItem);
}
}
if (itemlist.Size())
{
if (!bAllowVideo)
{
if (!bypassSettings)
return false;
if (g_windowManager.GetActiveWindow() != WINDOW_VIDEO_FILES)
if (!g_passwordManager.IsMasterLockUnlocked(true))
return false;
}
g_playlistPlayer.ClearPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Add(PLAYLIST_VIDEO, itemlist);
g_playlistPlayer.SetCurrentPlaylist(PLAYLIST_VIDEO);
g_playlistPlayer.Play(0);
}
}
// then music
if (!bPlaying && (bypassSettings || g_guiSettings.GetBool("autorun.music")) && bAllowMusic)
{
for (int i = 0; i < vecItems.Size(); i++)
{
CFileItemPtr pItem = vecItems[i];
if (!pItem->m_bIsFolder && pItem->IsAudio())
{
nAddedToPlaylist++;
g_playlistPlayer.Add(PLAYLIST_MUSIC, pItem);
}
}
}
// and finally pictures
if (!nAddedToPlaylist && !bPlaying && (bypassSettings || g_guiSettings.GetBool("autorun.pictures")) && bAllowPictures)
{
for (int i = 0; i < vecItems.Size(); i++)
{
CFileItemPtr pItem = vecItems[i];
if (!pItem->m_bIsFolder && pItem->IsPicture())
{
bPlaying = true;
CStdString strExec;
strExec.Format("XBMC.RecursiveSlideShow(%s)", strDrive.c_str());
CBuiltins::Execute(strExec);
break;
}
}
}
// check subdirs if we are not playing yet
if (!bPlaying)
{
for (int i = 0; i < vecItems.Size(); i++)
{
CFileItemPtr pItem = vecItems[i];
if (pItem->m_bIsFolder)
{
if (pItem->m_strPath != "." && pItem->m_strPath != ".." )
{
if (RunDisc(pDir, pItem->m_strPath, nAddedToPlaylist, false, bypassSettings))
{
bPlaying = true;
break;
}
}
}
}
}
return bPlaying;
}
int CMetadataResolverMusic::ReadMusicFolder(const CStdString& strPath, CResolvingFolder& folder, BXMetadataScannerJob* pJob)
{
CLog::Log(LOGDEBUG,"CMetadataResolverMusic::ReadMusicFolder reading music folder %s (musicresolver)", strPath.c_str());
// Update folder path
folder.strFolderPath = strPath;
// We wont try to resolve RAR or ZIP folder - in this case the files will stay unresolved
if (CUtil::IsRAR(strPath) || CUtil::IsZIP(strPath))
{
CLog::Log(LOGDEBUG,"CMetadataResolverMusic::ReadMusicFolder file %s is compressed file - keep it unresolved (musicresolver)", strPath.c_str());
return RESOLVER_SUCCESS;
}
CFileItemList items;
if (!DIRECTORY::CDirectory::GetDirectory(strPath, items))
{
CLog::Log(LOGDEBUG,"CMetadataResolverMusic::ReadMusicFolder unable to read directory %s (musicresolver)", strPath.c_str());
return RESOLVER_FAILED;
}
for (int i=0; i < items.Size() && pJob->IsActive(); i++)
{
CFileItemPtr pItem = items[i];
if (pItem->IsAudio() && !pItem->IsHidden() && !pItem->IsRAR() && !pItem->IsZIP() && !pItem->IsPlayList(false))
{
CResolvingTrack track(pItem->m_strPath);
track.strFolderPath = strPath;
folder.vecTracks.push_back(track);
}
else if (pItem->IsPlayList(false))
{
// TODO: Handle playlists
}
else if (pItem->IsPicture())
{
CStdString extension = CUtil::GetExtension(pItem->m_strPath);
CStdString supportedExtensions = ".png|.jpg|.jpeg|.bmp|.gif";
CStdStringArray thumbs;
StringUtils::SplitString(supportedExtensions, "|", thumbs);
for (unsigned int j = 0; j < thumbs.size(); ++j)
{
if (extension.CompareNoCase(thumbs[j]) == 0)
{
folder.vecThumbs.push_back(pItem->m_strPath);
break;
}
}
}
}
if (!pJob->IsActive())
{
CLog::Log(LOGDEBUG,"CMetadataResolverMusic::ReadMusicFolder aborted, resolver was paused when reading folder %s (pause) (musicresolver) ", strPath.c_str());
return RESOLVER_ABORTED;
}
folder.strFolderPath = strPath;
folder.strEffectiveFolderName = BOXEE::BXUtils::GetEffectiveFolderName(strPath);
CLog::Log(LOGDEBUG,"CMetadataResolverMusic::ReadMusicFolder successfully finished reading folder %s (musicresolver) ", strPath.c_str());
return RESOLVER_SUCCESS;
}
void CGUIWindowPictures::OnItemInfo(int itemNumber)
{
CFileItemPtr item = m_vecItems->Get(itemNumber);
if (!item)
return;
if (!m_vecItems->IsPlugin() && (item->IsPlugin() || item->IsScript()))
{
CGUIDialogAddonInfo::ShowForItem(item);
return;
}
if (item->m_bIsFolder || item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR() || !item->IsPicture())
return;
CGUIDialogPictureInfo *pictureInfo = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogPictureInfo>(WINDOW_DIALOG_PICTURE_INFO);
if (pictureInfo)
{
pictureInfo->SetPicture(item.get());
pictureInfo->Open();
}
}