std::string CFavouritesDirectory::GetExecutePath(const CFileItem &item, const std::string &contextWindow)
{
std::string execute;
if (item.m_bIsFolder && (g_advancedSettings.m_playlistAsFolders ||
!(item.IsSmartPlayList() || item.IsPlayList())))
{
if (!contextWindow.empty())
execute = StringUtils::Format("ActivateWindow(%s,%s,return)", contextWindow.c_str(), StringUtils::Paramify(item.GetPath()).c_str());
}
/* TODO:STRING_CLEANUP */
else if (item.IsAndroidApp() && item.GetPath().size() > 26) // androidapp://sources/apps/<foo>
execute = StringUtils::Format("StartAndroidActivity(%s)", StringUtils::Paramify(item.GetPath().substr(26)).c_str());
else // assume a media file
{
if (item.IsVideoDb() && item.HasVideoInfoTag())
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetVideoInfoTag()->m_strFileNameAndPath).c_str());
else if (item.IsMusicDb() && item.HasMusicInfoTag())
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetMusicInfoTag()->GetURL()).c_str());
else if (item.IsPicture())
execute = StringUtils::Format("ShowPicture(%s)", StringUtils::Paramify(item.GetPath()).c_str());
else
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetPath()).c_str());
}
return execute;
}
bool CGUIMultiImage::CMultiImageJob::DoWork()
{
// check to see if we have a single image or a folder of images
CFileItem item(m_path, false);
item.FillInMimeType();
if (item.IsPicture() || item.GetMimeType().Left(6).Equals("image/"))
{
m_files.push_back(m_path);
}
else
{
// Load in images from the directory specified
// m_path is relative (as are all skin paths)
CStdString realPath = g_TextureManager.GetTexturePath(m_path, true);
if (realPath.IsEmpty())
return true;
URIUtils::AddSlashAtEnd(realPath);
CFileItemList items;
CDirectory::GetDirectory(realPath, items, g_advancedSettings.m_pictureExtensions + "|.tbn|.dds", DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_NO_FILE_INFO);
for (int i=0; i < items.Size(); i++)
{
CFileItem* pItem = items[i].get();
if (pItem && (pItem->IsPicture() || pItem->GetMimeType().Left(6).Equals("image/")))
m_files.push_back(pItem->GetPath());
}
}
return true;
}
bool CGUIMultiImage::CMultiImageJob::DoWork()
{
// check to see if we have a single image or a folder of images
CFileItem item(m_path, false);
item.FillInMimeType();
if (item.IsPicture() || StringUtils::StartsWithNoCase(item.GetMimeType(), "image/"))
{
m_files.push_back(m_path);
}
else
{
// Load in images from the directory specified
// m_path is relative (as are all skin paths)
std::string realPath = CServiceBroker::GetGUI()->GetTextureManager().GetTexturePath(m_path, true);
if (realPath.empty())
return true;
URIUtils::AddSlashAtEnd(realPath);
CFileItemList items;
CDirectory::GetDirectory(realPath, items, CServiceBroker::GetFileExtensionProvider().GetPictureExtensions()+ "|.tbn|.dds", DIR_FLAG_NO_FILE_DIRS | DIR_FLAG_NO_FILE_INFO);
for (int i=0; i < items.Size(); i++)
{
CFileItem* pItem = items[i].get();
if (pItem && (pItem->IsPicture() || StringUtils::StartsWithNoCase(pItem->GetMimeType(), "image/")))
m_files.push_back(pItem->GetPath());
}
}
return true;
}
std::string CFavouritesService::GetExecutePath(const CFileItem &item, const std::string &contextWindow) const
{
std::string execute;
if (URIUtils::IsProtocol(item.GetPath(), "favourites"))
{
const CURL url(item.GetPath());
execute = CURL::Decode(url.GetHostName());
}
else if (item.m_bIsFolder && (g_advancedSettings.m_playlistAsFolders ||
!(item.IsSmartPlayList() || item.IsPlayList())))
{
if (!contextWindow.empty())
execute = StringUtils::Format("ActivateWindow(%s,%s,return)", contextWindow.c_str(), StringUtils::Paramify(item.GetPath()).c_str());
}
//! @todo STRING_CLEANUP
else if (item.IsScript() && item.GetPath().size() > 9) // script://<foo>
execute = StringUtils::Format("RunScript(%s)", StringUtils::Paramify(item.GetPath().substr(9)).c_str());
else if (item.IsAddonsPath() && item.GetPath().size() > 9) // addons://<foo>
{
CURL url(item.GetPath());
execute = StringUtils::Format("RunAddon(%s)", url.GetFileName().c_str());
}
else if (item.IsAndroidApp() && item.GetPath().size() > 26) // androidapp://sources/apps/<foo>
execute = StringUtils::Format("StartAndroidActivity(%s)", StringUtils::Paramify(item.GetPath().substr(26)).c_str());
else // assume a media file
{
if (item.IsVideoDb() && item.HasVideoInfoTag())
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetVideoInfoTag()->m_strFileNameAndPath).c_str());
else if (item.IsMusicDb() && item.HasMusicInfoTag())
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetMusicInfoTag()->GetURL()).c_str());
else if (item.IsPicture())
execute = StringUtils::Format("ShowPicture(%s)", StringUtils::Paramify(item.GetPath()).c_str());
else
execute = StringUtils::Format("PlayMedia(%s)", StringUtils::Paramify(item.GetPath()).c_str());
}
return execute;
}
bool CFileCache::Open(const CURI& url)
{
Close();
CSingleLock lock(m_sync);
CLog::Log(LOGDEBUG,"CFileCache::Open - opening <%s> using cache", url.GetFileName().c_str());
m_sourcePath = url.Get();
// opening the source file.
if(!m_source.Open(m_sourcePath, READ_NO_CACHE | READ_TRUNCATED | READ_CHUNKED)) {
CLog::Log(LOGERROR,"%s - failed to open source <%s>", __FUNCTION__, m_sourcePath.c_str());
Close();
return false;
}
// check if source can seek
m_seekPossible = m_source.Seek(0, SEEK_POSSIBLE);
m_bCanSeekBack = m_seekPossible ? true : false;
__int64 nLength = m_source.GetLength();
CFileItem item;
item.m_strPath = m_sourcePath;
item.SetContentType(GetContent());
if (m_pCache && m_bDeleteCache)
{
m_pCache->Close();
delete m_pCache;
}
m_bDeleteCache = true;
// we use file cache for files which are not seekable, pictures and in general small files (under 10 M)
if ( item.IsPicture() ||
( nLength > 0 && nLength < 15 * 1024 * 1024 ) ||
( 1 != m_seekPossible && nLength > 0 && nLength < (512*1024*1024) )
)
{
CLog::Log(LOGDEBUG, "%s - using file cache", __FUNCTION__);
m_pCache = new CSimpleFileCache;
m_bCanSeekBack = true;
}
else
{
CLog::Log(LOGDEBUG, "%s - using mem buffer cache", __FUNCTION__);
m_pCache = new CacheMemBuffer;
}
// open cache strategy
if (m_pCache->Open() != CACHE_RC_OK) {
CLog::Log(LOGERROR,"CFileCache::Open - failed to open cache");
Close();
return false;
}
m_readPos = 0;
m_seekEvent.Reset();
m_seekEnded.Reset();
CThread::Create(false);
Sleep(100);
return true;
}
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;
// for every file found, but skip folder
for (int i = 0; i < items.Size(); ++i)
{
CFileItem* pItem = items[i];
CStdString strExtension;
CUtil::GetExtension(pItem->m_strPath, strExtension);
if (m_bStop)
return 0;
// dont try reading id3tags for folders, playlists or shoutcast streams
if (!pItem->m_bIsFolder && !pItem->IsPlayList() && !pItem->IsShoutCast() && !pItem->IsPicture())
{
m_currentItem++;
// CLog::Log(LOGDEBUG, "%s - Reading tag for: %s", __FUNCTION__, pItem->m_strPath.c_str());
// grab info from the song
CSong *dbSong = songsMap.Find(pItem->m_strPath);
CMusicInfoTag& tag = *pItem->GetMusicInfoTag();
if (!tag.Loaded() )
{ // read the tag from a file
auto_ptr<IMusicInfoTagLoader> pLoader (CMusicInfoTagLoaderFactory::CreateLoader(pItem->m_strPath));
if (NULL != pLoader.get())
pLoader->Load(pItem->m_strPath, 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);
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;
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__, spItem->m_strPath.c_str());
}
else
CLog::Log(LOGDEBUG, "%s - No tag found for: %s", __FUNCTION__, pItem->m_strPath.c_str());
}
}
CheckForVariousArtists(songsToAdd);
if (!items.HasThumbnail())
UpdateFolderThumb(songsToAdd, items.m_strPath);
// finally, add these to the database
for (unsigned int i = 0; i < songsToAdd.size(); ++i)
{
if (m_bStop) return i;
CSong &song = songsToAdd[i];
m_musicDatabase.AddSong(song, false);
if (!m_bStop && g_guiSettings.GetBool("musiclibrary.autoartistinfo"))
{
long iArtist = m_musicDatabase.GetArtistByName(song.strArtist);
CStdString strPath;
strPath.Format("musicdb://2/%u/",iArtist);
if (find(m_artistsScanned.begin(),m_artistsScanned.end(),iArtist) == m_artistsScanned.end())
if (DownloadArtistInfo(strPath,song.strArtist))
m_artistsScanned.push_back(iArtist);
if (m_pObserver)
m_pObserver->OnStateChanged(READING_MUSIC_INFO);
}
if (!m_bStop && g_guiSettings.GetBool("musiclibrary.autoalbuminfo"))
{
long iAlbum = m_musicDatabase.GetAlbumByName(song.strAlbum,song.strArtist);
CStdString strPath;
strPath.Format("musicdb://3/%u/",iAlbum);
CMusicAlbumInfo albumInfo;
bool bCanceled;
if (find(m_albumsScanned.begin(),m_albumsScanned.end(),iAlbum) == m_albumsScanned.end())
if (DownloadAlbumInfo(strPath,song.strArtist,song.strAlbum,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++)
{
CFileItem* 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());
CUtil::ExecBuiltIn(strExec);
return true;
}
}
}
}
// check video first
if (!nAddedToPlaylist && !bPlaying && (bypassSettings || g_guiSettings.GetBool("autorun.video")))
{
// stack video files
CFileItemList tempItems;
tempItems.Append(vecItems);
tempItems.Stack();
CFileItemList itemlist;
for (int i = 0; i < tempItems.Size(); i++)
{
CFileItem *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);
for (int i = 0; i < items.Size(); i++)
{
itemlist.Add(new CFileItem(*items[i]));
}
}
else
itemlist.Add(new CFileItem(*pItem));
}
}
if (itemlist.Size())
{
if (!bAllowVideo)
{
if (!bypassSettings)
return false;
if (m_gWindowManager.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++)
{
CFileItem *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++)
{
CFileItem *pItem = vecItems[i];
if (!pItem->m_bIsFolder && pItem->IsPicture())
{
bPlaying = true;
CStdString strExec;
strExec.Format("XBMC.RecursiveSlideShow(%s)", strDrive.c_str());
CUtil::ExecBuiltIn(strExec);
break;
}
}
}
// check subdirs if we are not playing yet
if (!bPlaying)
{
for (int i = 0; i < vecItems.Size(); i++)
{
CFileItem* 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;
}
//*********************************************************************************************
bool CFile::Open(const CStdString& strFileName, bool bBinary, unsigned int flags)
{
m_flags = flags;
try
{
bool bPathInCache;
if (!g_directoryCache.FileExists(strFileName, bPathInCache) )
{
if (bPathInCache)
return false;
}
CFileItem fileItem;
fileItem.m_strPath = strFileName;
if ( (flags & READ_NO_CACHE) == 0 && fileItem.IsInternetStream() && !fileItem.IsPicture())
m_flags |= READ_CACHED;
CURL url(strFileName);
if (m_flags & READ_CACHED)
{
m_pFile = new CFileCache();
return m_pFile->Open(url, bBinary);
}
m_pFile = CFileFactory::CreateLoader(url);
if (!m_pFile)
return false;
try
{
if (!m_pFile->Open(url, bBinary))
{
SAFE_DELETE(m_pFile);
return false;
}
}
catch (CRedirectException *pRedirectEx)
{
// the file implementation decided this item should use a different implementation.
// the exception will contain the new implementation.
CLog::Log(LOGDEBUG,"File::Open - redirecting implementation for %s", strFileName.c_str());
SAFE_DELETE(m_pFile);
if (pRedirectEx && pRedirectEx->m_pNewFileImp)
{
m_pFile = pRedirectEx->m_pNewFileImp;
delete pRedirectEx;
if (!m_pFile->Open(url, bBinary))
{
SAFE_DELETE(m_pFile);
return false;
}
}
}
catch (...)
{
CLog::Log(LOGDEBUG,"File::Open - unknown exception when opening %s", strFileName.c_str());
SAFE_DELETE(m_pFile);
return false;
}
if (m_flags & READ_BUFFERED)
{
if (m_pFile->GetChunkSize())
{
m_pBuffer = new CFileStreamBuffer(0);
m_pBuffer->Attach(m_pFile);
}
}
m_bitStreamStats.Start();
return true;
}
#ifndef _LINUX
catch (const win32_exception &e)
{
e.writelog(__FUNCTION__);
}
#endif
catch(...)
{
CLog::Log(LOGERROR, "%s - Unhandled exception", __FUNCTION__);
}
CLog::Log(LOGERROR, "%s - Error opening %s", __FUNCTION__, strFileName.c_str());
return false;
}
