/// Deletes the file associated with a metadata entry
bool VideoMetadataImp::DeleteFile()
{
bool isremoved = false;
if (!m_host.isEmpty())
{
QString url = generate_file_url("Videos", m_host, m_filename);
isremoved = RemoteFile::DeleteFile(url);
}
else
{
QFileInfo fi(m_filename);
if (fi.isDir())
{
isremoved = removeDir(m_filename);
}
else
{
isremoved = QFile::remove(m_filename);
}
}
if (!isremoved)
{
LOG(VB_GENERAL, LOG_DEBUG, QString("Could not delete file: %1")
.arg(m_filename));
}
return isremoved;
}
void PlayerFor(const VideoMetadata *item)
{
if (item)
{
QString play_command = item->GetPlayCommand();
QString filename;
if (item->IsHostSet())
filename = generate_file_url("Videos", item->GetHost(),
item->GetFilename());
else
filename = item->GetFilename();
if (play_command.length())
{
AddPlayer(play_command, filename, item->GetPlot(),
item->GetTitle(), item->GetSubtitle(),
item->GetDirector(), item->GetSeason(),
item->GetEpisode(), item->GetInetRef(),
item->GetLength(), QString::number(item->GetYear()));
}
else
{
PlayerFor(filename, item);
}
}
}
bool Frontend::PlayVideo(const QString &Id, bool UseBookmark)
{
if (TV::IsTVRunning())
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
QString("Ignoring PlayVideo request - frontend is busy."));
return false;
}
bool ok;
quint64 id = Id.toUInt(&ok);
if (!ok)
{
LOG(VB_GENERAL, LOG_WARNING, LOC + QString("Invalid video Id."));
return false;
}
VideoMetadataListManager::VideoMetadataPtr metadata =
VideoMetadataListManager::loadOneFromDatabase(id);
if (!metadata)
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
QString("Didn't find any video metadata."));
return false;
}
if (metadata->GetHost().isEmpty())
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
QString("No host for video."));
return false;
}
QString mrl = generate_file_url("Videos", metadata->GetHost(),
metadata->GetFilename());
LOG(VB_GENERAL, LOG_INFO, LOC +
QString("PlayVideo, id: %1 usebookmark: %2 url: '%3'")
.arg(id).arg(UseBookmark).arg(mrl));
QStringList args;
args << mrl << metadata->GetPlot() << metadata->GetTitle()
<< metadata->GetSubtitle() << metadata->GetDirector()
<< QString::number(metadata->GetSeason())
<< QString::number(metadata->GetEpisode())
<< metadata->GetInetRef() << QString::number(metadata->GetLength())
<< QString::number(metadata->GetYear())
<< QString::number(metadata->GetID())
<< QString::number(UseBookmark);
MythEvent *me = new MythEvent(ACTION_HANDLEMEDIA, args);
qApp->postEvent(GetMythMainWindow(), me);
return true;
}
void EditMetadataDialog::FindTrailer()
{
if (!m_workingMetadata->GetHost().isEmpty())
{
QString url = generate_file_url("Trailers",
m_workingMetadata->GetHost(),
"");
FindVideoFilePopup(url,"",
*this, CEID_TRAILERFILE);
}
else
FindVideoFilePopup(gCoreContext->GetSetting("mythvideo.TrailersDir"),
GetConfDir() + "/MythVideo/Trailers",
*this, CEID_TRAILERFILE);
}
void EditMetadataDialog::FindScreenshot()
{
if (!m_workingMetadata->GetHost().isEmpty())
{
QString url = generate_file_url("Screenshots",
m_workingMetadata->GetHost(),
"");
FindImagePopup(url,"",
*this, CEID_SCREENSHOTFILE);
}
else
FindImagePopup(gCoreContext->GetSetting("mythvideo.screenshotDir"),
GetConfDir() + "/MythVideo/Screenshots",
*this, CEID_SCREENSHOTFILE);
}
void EditMetadataDialog::FindFanart()
{
if (!m_workingMetadata->GetHost().isEmpty())
{
QString url = generate_file_url("Fanart",
m_workingMetadata->GetHost(),
"");
FindImagePopup(url,"",
*this, CEID_FANARTFILE);
}
else
FindImagePopup(gCoreContext->GetSetting("mythvideo.fanartDir"),
GetConfDir() + "/MythVideo/Fanart",
*this, CEID_FANARTFILE);
}
void EditMetadataDialog::FindBanner()
{
if (!m_workingMetadata->GetHost().isEmpty())
{
QString url = generate_file_url("Banners",
m_workingMetadata->GetHost(),
"");
FindImagePopup(url,"",
*this, CEID_BANNERFILE);
}
else
FindImagePopup(gCoreContext->GetSetting("mythvideo.bannerDir"),
GetConfDir() + "/MythVideo/Banners",
*this, CEID_BANNERFILE);
}
void EditMetadataDialog::FindCoverArt()
{
if (!m_workingMetadata->GetHost().isEmpty())
{
QString url = generate_file_url("Coverart",
m_workingMetadata->GetHost(),
"");
FindImagePopup(url,"",
*this, CEID_COVERARTFILE);
}
else
FindImagePopup(gCoreContext->GetSetting("VideoArtworkDir"),
GetConfDir() + "/MythVideo",
*this, CEID_COVERARTFILE);
}
QString VideoMetadata::VideoFileHash(const QString &file_name,
const QString &host)
{
if (!host.isEmpty() && !isHostMaster(host))
{
QString url = generate_file_url("Videos", host, file_name);
return RemoteFile::GetFileHash(url);
}
else if (!host.isEmpty())
{
StorageGroup sgroup("Videos", host);
QString fullname = sgroup.FindFile(file_name);
return FileHash(fullname);
}
else
return FileHash(file_name);
}
static void UpdateHashes(void)
{
MSqlQuery query(MSqlQuery::InitCon());
query.prepare("SELECT `filename`, `host` FROM videometadata WHERE "
"`hash` = \"\"");
if (query.exec() && query.size())
{
while (query.next())
{
QString filename = query.value(0).toString();
QString host = query.value(1).toString();
QString hash;
if (!host.isEmpty())
{
QString url = generate_file_url("Videos", host, filename);
hash = RemoteFile::GetFileHash(url);
}
else
hash = FileHash(filename);
if (hash == "NULL")
hash = QString();
MSqlQuery updatequery(MSqlQuery::InitCon());
updatequery.prepare("UPDATE videometadata set `hash` = :HASH "
"WHERE `filename` = :FILENAME AND "
"`host` = :HOST");
updatequery.bindValue(":HASH", hash);
updatequery.bindValue(":FILENAME", filename);
updatequery.bindValue(":HOST", host);
if (!updatequery.exec())
MythDB::DBError(QObject::tr("Error: failed to hash file "
"'%1'").arg(filename), updatequery);
else
LOG(VB_GENERAL, LOG_INFO,
QString("Hash (%1) generated for file (%2)")
.arg(hash).arg(filename));
}
}
}
void VideoSetupWizard::testHDVideo(void)
{
QString hdtestfile = generate_file_url("Temp",
gCoreContext->GetMasterHostName(),
VIDEO_SAMPLE_HD_FILENAME);
QString desiredpbp =
m_playbackProfileButtonList->GetItemCurrent()->GetText();
QString desc = tr("A short test of your system's playback of "
"High Definition content with the %1 profile.")
.arg(desiredpbp);
QString title = tr("High Definition Playback Test");
if (!RemoteFile::Exists(hdtestfile))
{
m_testType = ttHighDefinition;
DownloadSample(VIDEO_SAMPLE_HD_LOCATION, VIDEO_SAMPLE_HD_FILENAME);
}
else
playVideoTest(desc, title, hdtestfile);
}
void NetTree::doDownloadAndPlay()
{
ResultItem *item;
if (m_type == DLG_TREE)
item = qVariantValue<ResultItem *>(m_siteMap->GetCurrentNode()->GetData());
else
{
MythGenericTree *node = GetNodePtrFromButton(m_siteButtonList->GetItemCurrent());
if (!node)
return;
item = qVariantValue<ResultItem *>(node->GetData());
}
if (!item)
return;
QString baseFilename = GetDownloadFilename(item->GetTitle(),
item->GetMediaURL());
QString finalFilename = generate_file_url("Default",
gCoreContext->GetMasterHostName(),
baseFilename);
LOG(VB_GENERAL, LOG_INFO, QString("Downloading %1 to %2")
.arg(item->GetMediaURL()) .arg(finalFilename));
// Does the file already exist?
bool exists = RemoteFile::Exists(finalFilename);
if (exists)
{
doPlayVideo(finalFilename);
return;
}
else
DownloadVideo(item->GetMediaURL(), baseFilename);
}
void MetadataFactory::Lookup(VideoMetadata *metadata, bool automatic,
bool getimages, bool allowgeneric)
{
if (!metadata)
return;
MetadataLookup *lookup = new MetadataLookup();
lookup->SetStep(kLookupSearch);
lookup->SetType(kMetadataVideo);
if (metadata->GetSeason() > 0 || metadata->GetEpisode() > 0)
lookup->SetSubtype(kProbableTelevision);
else if (metadata->GetSubtitle().isEmpty())
lookup->SetSubtype(kProbableMovie);
else
lookup->SetSubtype(kUnknownVideo);
lookup->SetData(qVariantFromValue(metadata));
lookup->SetAutomatic(automatic);
lookup->SetHandleImages(getimages);
lookup->SetAllowGeneric(allowgeneric);
lookup->SetHost(metadata->GetHost());
lookup->SetTitle(metadata->GetTitle());
lookup->SetSubtitle(metadata->GetSubtitle());
lookup->SetSeason(metadata->GetSeason());
lookup->SetEpisode(metadata->GetEpisode());
lookup->SetInetref(metadata->GetInetRef());
QString fntmp;
if (metadata->GetHost().isEmpty())
fntmp = metadata->GetFilename();
else
fntmp = generate_file_url("Videos", metadata->GetHost(),
metadata->GetFilename());
lookup->SetFilename(fntmp);
if (m_lookupthread->isRunning())
m_lookupthread->prependLookup(lookup);
else
m_lookupthread->addLookup(lookup);
}
void VideoMetadata::toMap(MetadataMap &metadataMap)
{
if (this == NULL)
return;
QString coverfile;
if (IsHostSet()
&& !GetCoverFile().startsWith("/")
&& !GetCoverFile().isEmpty()
&& !IsDefaultCoverFile(GetCoverFile()))
{
coverfile = generate_file_url("Coverart", GetHost(),
GetCoverFile());
}
else
{
coverfile = GetCoverFile();
}
metadataMap["coverfile"] = coverfile;
QString screenshotfile;
if (IsHostSet() && !GetScreenshot().startsWith("/")
&& !GetScreenshot().isEmpty())
{
screenshotfile = generate_file_url("Screenshots",
GetHost(), GetScreenshot());
}
else
{
screenshotfile = GetScreenshot();
}
metadataMap["screenshotfile"] = screenshotfile;
QString bannerfile;
if (IsHostSet() && !GetBanner().startsWith("/")
&& !GetBanner().isEmpty())
{
bannerfile = generate_file_url("Banners", GetHost(),
GetBanner());
}
else
{
bannerfile = GetBanner();
}
metadataMap["bannerfile"] = bannerfile;
QString fanartfile;
if (IsHostSet() && !GetFanart().startsWith("/")
&& !GetFanart().isEmpty())
{
fanartfile = generate_file_url("Fanart", GetHost(),
GetFanart());
}
else
{
fanartfile = GetFanart();
}
metadataMap["fanartfile"] = fanartfile;
metadataMap["filename"] = GetFilename();
metadataMap["title"] = GetTitle();
metadataMap["subtitle"] = GetSubtitle();
metadataMap["tagline"] = GetTagline();
metadataMap["director"] = GetDirector();
metadataMap["studio"] = GetStudio();
metadataMap["description"] = GetPlot();
metadataMap["genres"] = GetDisplayGenres(*this);
metadataMap["countries"] = GetDisplayCountries(*this);
metadataMap["cast"] = GetDisplayCast(*this).join(", ");
metadataMap["rating"] = GetDisplayRating(GetRating());
metadataMap["length"] = GetDisplayLength(GetLength());
metadataMap["year"] = GetDisplayYear(GetYear());
metadataMap["releasedate"] = MythDateToString(GetReleaseDate(), kDateFull);
metadataMap["userrating"] = GetDisplayUserRating(GetUserRating());
metadataMap["season"] = GetDisplaySeasonEpisode(GetSeason(), 1);
metadataMap["episode"] = GetDisplaySeasonEpisode(GetEpisode(), 1);
if (GetSeason() > 0 || GetEpisode() > 0)
{
metadataMap["s##e##"] = QString("s%1e%2").arg(GetDisplaySeasonEpisode
(GetSeason(), 2))
.arg(GetDisplaySeasonEpisode(GetEpisode(), 2));
metadataMap["##x##"] = QString("%1x%2").arg(GetDisplaySeasonEpisode
(GetSeason(), 1))
.arg(GetDisplaySeasonEpisode(GetEpisode(), 2));
}
else
metadataMap["s##e##"] = metadataMap["##x##"] = QString();
metadataMap["trailerstate"] = TrailerToState(GetTrailer());
metadataMap["userratingstate"] =
QString::number((int)(GetUserRating()));
metadataMap["watchedstate"] = WatchedToState(GetWatched());
metadataMap["videolevel"] = ParentalLevelToState(GetShowLevel());
metadataMap["insertdate"] = MythDateToString(GetInsertdate(), kDateFull);
metadataMap["inetref"] = GetInetRef();
metadataMap["homepage"] = GetHomepage();
metadataMap["child_id"] = QString::number(GetChildID());
metadataMap["browseable"] = GetDisplayBrowse(GetBrowse());
metadataMap["watched"] = GetDisplayWatched(GetWatched());
metadataMap["processed"] = GetDisplayProcessed(GetProcessed());
metadataMap["category"] = GetCategory();
}
void EditMetadataDialog::fillWidgets()
{
m_titleEdit->SetText(m_workingMetadata->GetTitle());
m_subtitleEdit->SetText(m_workingMetadata->GetSubtitle());
m_seasonSpin->SetRange(0,9999,1,5);
m_seasonSpin->SetValue(m_workingMetadata->GetSeason());
m_episodeSpin->SetRange(0,999,1,10);
m_episodeSpin->SetValue(m_workingMetadata->GetEpisode());
if (m_yearSpin)
{
m_yearSpin->SetRange(0,9999,1,10);
m_yearSpin->SetValue(m_workingMetadata->GetYear());
}
if (m_userRatingSpin)
{
m_userRatingSpin->SetRange(0,10,1,2);
m_userRatingSpin->SetValue(m_workingMetadata->GetUserRating());
}
if (m_lengthSpin)
{
m_lengthSpin->SetRange(0,999,1,15);
m_lengthSpin->SetValue(m_workingMetadata->GetLength());
}
MythUIButtonListItem *button =
new MythUIButtonListItem(m_categoryList, VIDEO_CATEGORY_UNKNOWN);
const VideoCategory::entry_list &vcl =
VideoCategory::GetCategory().getList();
for (VideoCategory::entry_list::const_iterator p = vcl.begin();
p != vcl.end(); ++p)
{
button = new MythUIButtonListItem(m_categoryList, p->second);
button->SetData(p->first);
}
m_categoryList->SetValueByData(m_workingMetadata->GetCategoryID());
for (ParentalLevel i = ParentalLevel::plLowest;
i <= ParentalLevel::plHigh && i.good(); ++i)
{
button = new MythUIButtonListItem(m_levelList,
tr("Level %1").arg(i.GetLevel()));
button->SetData(i.GetLevel());
}
m_levelList->SetValueByData(m_workingMetadata->GetShowLevel());
//
// Fill the "always play this video next" option
// with all available videos.
//
button = new MythUIButtonListItem(m_childList,tr("None"));
// TODO: maybe make the title list have the same sort order
// as elsewhere.
typedef std::vector<std::pair<unsigned int, QString> > title_list;
const VideoMetadataListManager::metadata_list &mdl = m_metaCache.getList();
title_list tc;
tc.reserve(mdl.size());
for (VideoMetadataListManager::metadata_list::const_iterator p = mdl.begin();
p != mdl.end(); ++p)
{
QString title;
if ((*p)->GetSeason() > 0 || (*p)->GetEpisode() > 0)
title = QString("%1 %2x%3").arg((*p)->GetTitle())
.arg(QString::number((*p)->GetSeason()))
.arg(QString::number((*p)->GetEpisode()));
else
title = (*p)->GetTitle();
tc.push_back(std::make_pair((*p)->GetID(), title));
}
std::sort(tc.begin(), tc.end(), title_sort<title_list::value_type>());
for (title_list::const_iterator p = tc.begin(); p != tc.end(); ++p)
{
if (p->first != m_workingMetadata->GetID())
{
button = new MythUIButtonListItem(m_childList,p->second);
button->SetData(p->first);
}
}
if (m_workingMetadata->GetChildID() > 0)
{
m_childList->SetValueByData(m_workingMetadata->GetChildID());
cachedChildSelection = m_workingMetadata->GetChildID();
}
if (m_workingMetadata->GetBrowse())
m_browseCheck->SetCheckState(MythUIStateType::Full);
if (m_workingMetadata->GetWatched())
m_watchedCheck->SetCheckState(MythUIStateType::Full);
if (m_coverartText)
m_coverartText->SetText(m_workingMetadata->GetCoverFile());
if (m_screenshotText)
m_screenshotText->SetText(m_workingMetadata->GetScreenshot());
if (m_bannerText)
m_bannerText->SetText(m_workingMetadata->GetBanner());
if (m_fanartText)
m_fanartText->SetText(m_workingMetadata->GetFanart());
if (m_trailerText)
m_trailerText->SetText(m_workingMetadata->GetTrailer());
m_playerEdit->SetText(m_workingMetadata->GetPlayCommand());
if (m_taglineEdit)
m_taglineEdit->SetText(m_workingMetadata->GetTagline());
if (m_ratingEdit)
m_ratingEdit->SetText(m_workingMetadata->GetRating());
if (m_directorEdit)
m_directorEdit->SetText(m_workingMetadata->GetDirector());
if (m_inetrefEdit)
m_inetrefEdit->SetText(m_workingMetadata->GetInetRef());
if (m_homepageEdit)
m_homepageEdit->SetText(m_workingMetadata->GetHomepage());
if (m_plotEdit)
m_plotEdit->SetText(m_workingMetadata->GetPlot());
if (m_coverart)
{
if (!m_workingMetadata->GetHost().isEmpty() &&
!m_workingMetadata->GetCoverFile().isEmpty() &&
!m_workingMetadata->GetCoverFile().startsWith("/"))
{
m_coverart->SetFilename(generate_file_url("Coverart",
m_workingMetadata->GetHost(),
m_workingMetadata->GetCoverFile()));
}
else
m_coverart->SetFilename(m_workingMetadata->GetCoverFile());
if (!m_workingMetadata->GetCoverFile().isEmpty())
m_coverart->Load();
}
if (m_screenshot)
{
if (!m_workingMetadata->GetHost().isEmpty() &&
!m_workingMetadata->GetScreenshot().isEmpty() &&
!m_workingMetadata->GetScreenshot().startsWith("/"))
{
m_screenshot->SetFilename(generate_file_url("Screenshots",
m_workingMetadata->GetHost(),
m_workingMetadata->GetScreenshot()));
}
else
m_screenshot->SetFilename(m_workingMetadata->GetScreenshot());
if (!m_workingMetadata->GetScreenshot().isEmpty())
m_screenshot->Load();
}
if (m_banner)
{
if (!m_workingMetadata->GetHost().isEmpty() &&
!m_workingMetadata->GetBanner().isEmpty() &&
!m_workingMetadata->GetBanner().startsWith("/"))
{
m_banner->SetFilename(generate_file_url("Banners",
m_workingMetadata->GetHost(),
m_workingMetadata->GetBanner()));
}
else
m_banner->SetFilename(m_workingMetadata->GetBanner());
if (!m_workingMetadata->GetBanner().isEmpty())
m_banner->Load();
}
if (m_fanart)
{
if (!m_workingMetadata->GetHost().isEmpty() &&
!m_workingMetadata->GetFanart().isEmpty() &&
!m_workingMetadata->GetFanart().startsWith("/"))
{
m_fanart->SetFilename(generate_file_url("Fanart",
m_workingMetadata->GetHost(),
m_workingMetadata->GetFanart()));
}
else
m_fanart->SetFilename(m_workingMetadata->GetFanart());
if (!m_workingMetadata->GetFanart().isEmpty())
m_fanart->Load();
}
}
