QFileInfo Content::GetRecordingArtwork ( const QString &sType,
const QString &sInetref,
int nSeason,
int nWidth,
int nHeight)
{
ArtworkMap map = GetArtwork(sInetref, nSeason);
VideoArtworkType type = kArtworkCoverart;
QString sgroup;
if (sType.toLower() == "coverart")
{
sgroup = "Coverart";
type = kArtworkCoverart;
}
else if (sType.toLower() == "fanart")
{
sgroup = "Fanart";
type = kArtworkFanart;
}
else if (sType.toLower() == "banner")
{
sgroup = "Banners";
type = kArtworkBanner;
}
QUrl url(map.value(type).url);
QString sFileName = url.path();
return GetImageFile( sgroup, sFileName, nWidth, nHeight);
}
void EditMetadataDialog::OnSearchListSelection(ArtworkInfo info, VideoArtworkType type)
{
QString msg = tr("Downloading selected artwork...");
createBusyDialog(msg);
MetadataLookup *lookup = new MetadataLookup();
lookup->SetType(kMetadataVideo);
if (m_workingMetadata->GetSeason() > 0 ||
m_workingMetadata->GetEpisode() > 0)
lookup->SetSubtype(kProbableTelevision);
else if (m_workingMetadata->GetSubtitle().isEmpty())
lookup->SetSubtype(kProbableMovie);
else
lookup->SetSubtype(kUnknownVideo);
lookup->SetHost(m_workingMetadata->GetHost());
lookup->SetAutomatic(true);
lookup->SetData(qVariantFromValue<VideoArtworkType>(type));
ArtworkMap downloads;
downloads.insert(type, info);
lookup->SetDownloads(downloads);
lookup->SetAllowOverwrites(true);
lookup->SetTitle(m_workingMetadata->GetTitle());
lookup->SetSubtitle(m_workingMetadata->GetSubtitle());
lookup->SetSeason(m_workingMetadata->GetSeason());
lookup->SetEpisode(m_workingMetadata->GetEpisode());
lookup->SetInetref(m_workingMetadata->GetInetRef());
m_imageDownload->addDownloads(lookup);
}
void EditMetadataDialog::handleDownloadedImages(MetadataLookup *lookup)
{
if (!lookup)
return;
if (m_busyPopup)
{
m_busyPopup->Close();
m_busyPopup = NULL;
}
VideoArtworkType type = lookup->GetData().value<VideoArtworkType>();
ArtworkMap map = lookup->GetDownloads();
if (map.count() >= 1)
{
ArtworkInfo info = map.value(type);
QString filename = info.url;
if (type == kArtworkCoverart)
SetCoverArt(filename);
else if (type == kArtworkFanart)
SetFanart(filename);
else if (type == kArtworkBanner)
SetBanner(filename);
else if (type == kArtworkScreenshot)
SetScreenshot(filename);
}
}
bool SetArtwork(const QString &inetref,
uint season,
const QString &host,
const QString &coverart,
const QString &fanart,
const QString &banner)
{
bool ret = false;
ArtworkMap map;
if (!coverart.isEmpty())
{
ArtworkInfo coverartinfo;
coverartinfo.url = generate_myth_url("Coverart", host, coverart);
map.insert(kArtworkCoverart, coverartinfo);
}
if (!fanart.isEmpty())
{
ArtworkInfo fanartinfo;
fanartinfo.url = generate_myth_url("Fanart", host, fanart);
map.insert(kArtworkFanart, fanartinfo);
}
if (!banner.isEmpty())
{
ArtworkInfo bannerinfo;
bannerinfo.url = generate_myth_url("Banners", host, banner);
map.insert(kArtworkBanner, bannerinfo);
}
ret = SetArtwork(inetref, season, host, map);
return ret;
}
ArtworkMap GetArtwork(QString inetref,
uint season,
bool strict)
{
ArtworkMap map;
MSqlQuery query(MSqlQuery::InitCon());
QString querystring = "SELECT host, coverart, fanart, banner "
"FROM recordedartwork WHERE inetref = :INETREF ";
if (strict)
querystring += "AND season = :SEASON;";
else
querystring += "ORDER BY season = :SEASON DESC, season DESC;";
query.prepare(querystring);
query.bindValue(":INETREF", inetref);
query.bindValue(":SEASON", season);
if (!query.exec())
{
MythDB::DBError("GetArtwork SELECT", query);
return map;
}
if (query.next())
{
QString host = query.value(0).toString();
QString coverart = query.value(1).toString();
QString fanart = query.value(2).toString();
QString banner = query.value(3).toString();
if (!coverart.isEmpty())
{
ArtworkInfo coverartinfo;
coverartinfo.url = generate_myth_url("Coverart", host, coverart);
map.insert(kArtworkCoverart, coverartinfo);
}
if (!fanart.isEmpty())
{
ArtworkInfo fanartinfo;
fanartinfo.url = generate_myth_url("Fanart", host, fanart);
map.insert(kArtworkFanart, fanartinfo);
}
if (!banner.isEmpty())
{
ArtworkInfo bannerinfo;
bannerinfo.url = generate_myth_url("Banners", host, banner);
map.insert(kArtworkBanner, bannerinfo);
}
}
return map;
}
ArtworkMap ParseArtwork(QDomElement artwork)
{
ArtworkMap ret;
QDomElement image = artwork.firstChildElement("image");
if (!image.isNull())
{
while (!image.isNull())
{
if (image.hasAttribute("type"))
{
QString typestring = image.attribute("type");
VideoArtworkType type;
if (typestring.toLower() == "coverart")
type = kArtworkCoverart;
else if (typestring.toLower() == "fanart")
type = kArtworkFanart;
else if (typestring.toLower() == "banner")
type = kArtworkBanner;
else if (typestring.toLower() == "screenshot")
type = kArtworkScreenshot;
else if (typestring.toLower() == "poster")
type = kArtworkPoster;
else if (typestring.toLower() == "back cover")
type = kArtworkBackCover;
else if (typestring.toLower() == "inside cover")
type = kArtworkInsideCover;
else if (typestring.toLower() == "cd image")
type = kArtworkCDImage;
else
type = kArtworkCoverart;
ArtworkInfo info;
if (image.hasAttribute("thumb"))
info.thumbnail = image.attribute("thumb");
if (image.hasAttribute("url"))
info.url = image.attribute("url");
if (image.hasAttribute("width"))
info.width = image.attribute("width").toUInt();
else
info.width = 0;
if (image.hasAttribute("height"))
info.height = image.attribute("height").toUInt();
else
info.height = 0;
ret.insert(type,info);
}
image = image.nextSiblingElement("image");
}
}
return ret;
}
ArtworkMap ParseArtwork(QDomElement artwork)
{
ArtworkMap ret;
QDomElement image = artwork.firstChildElement("image");
if (!image.isNull())
{
while (!image.isNull())
{
if (image.hasAttribute("type"))
{
QString typestring = image.attribute("type");
VideoArtworkType type;
if (typestring.toLower() == "coverart")
type = COVERART;
else if (typestring.toLower() == "fanart")
type = FANART;
else if (typestring.toLower() == "banner")
type = BANNER;
else if (typestring.toLower() == "screenshot")
type = SCREENSHOT;
else if (typestring.toLower() == "poster")
type = POSTER;
else if (typestring.toLower() == "back cover")
type = BACKCOVER;
else if (typestring.toLower() == "inside cover")
type = INSIDECOVER;
else if (typestring.toLower() == "cd image")
type = CDIMAGE;
else
type = COVERART;
ArtworkInfo info;
if (image.hasAttribute("thumb"))
info.thumbnail = image.attribute("thumb");
if (image.hasAttribute("url"))
info.url = image.attribute("url");
if (image.hasAttribute("width"))
info.width = image.attribute("width").toUInt();
else
info.width = 0;
if (image.hasAttribute("height"))
info.height = image.attribute("height").toUInt();
else
info.height = 0;
ret.insert(type,info);
}
image = image.nextSiblingElement("image");
}
}
return ret;
}
void GameUI::StartGameImageSet(MythGenericTree *node, QStringList coverart,
QStringList fanart, QStringList screenshot)
{
if (!node)
return;
RomInfo *metadata = qVariantValue<RomInfo *>(node->GetData());
if (!metadata)
return;
ArtworkMap map;
QString inetref = metadata->Inetref();
QString system = metadata->System();
QString title = metadata->Gamename();
if (metadata->Boxart().isEmpty() && coverart.size())
{
ArtworkInfo info;
info.url = coverart.takeAt(0).trimmed();
map.insert(kArtworkCoverart, info);
}
if (metadata->Fanart().isEmpty() && fanart.size())
{
ArtworkInfo info;
info.url = fanart.takeAt(0).trimmed();
map.insert(kArtworkFanart, info);
}
if (metadata->Screenshot().isEmpty() && screenshot.size())
{
ArtworkInfo info;
info.url = screenshot.takeAt(0).trimmed();
map.insert(kArtworkScreenshot, info);
}
MetadataLookup *lookup = new MetadataLookup();
lookup->SetTitle(metadata->Gamename());
lookup->SetSystem(metadata->System());
lookup->SetInetref(metadata->Inetref());
lookup->SetType(kMetadataGame);
lookup->SetDownloads(map);
lookup->SetData(qVariantFromValue(node));
m_imageDownload->addDownloads(lookup);
}
bool PlayerContext::GetPlayingInfoMap(InfoMap &infoMap) const
{
bool loaded = false;
LockPlayingInfo(__FILE__, __LINE__);
if (playingInfo)
{
playingInfo->ToMap(infoMap);
infoMap["tvstate"] = StateToString(playingState);
infoMap["iconpath"] = ChannelUtil::GetIcon(playingInfo->GetChanID());
if ((playingInfo->IsVideoFile() || playingInfo->IsVideoDVD() ||
playingInfo->IsVideoBD()) && playingInfo->GetPathname() !=
playingInfo->GetBasename())
{
infoMap["coverartpath"] = VideoMetaDataUtil::GetArtPath(
playingInfo->GetPathname(), "Coverart");
infoMap["fanartpath"] = VideoMetaDataUtil::GetArtPath(
playingInfo->GetPathname(), "Fanart");
infoMap["bannerpath"] = VideoMetaDataUtil::GetArtPath(
playingInfo->GetPathname(), "Banners");
infoMap["screenshotpath"] = VideoMetaDataUtil::GetArtPath(
playingInfo->GetPathname(), "Screenshots");
}
else
{
ArtworkMap artmap = GetArtwork(playingInfo->GetInetRef(),
playingInfo->GetSeason());
infoMap["coverartpath"] =
artmap.value(kArtworkCoverart).url;
infoMap["fanartpath"] =
artmap.value(kArtworkFanart).url;
infoMap["bannerpath"] =
artmap.value(kArtworkBanner).url;
infoMap["screenshotpath"] =
artmap.value(kArtworkScreenshot).url;
}
if (player)
player->GetCodecDescription(infoMap);
infoMap.detach();
loaded = true;
}
UnlockPlayingInfo(__FILE__, __LINE__);
return loaded;
}
void FillArtworkInfoList( DTC::ArtworkInfoList *pArtworkInfoList,
const QString &sInetref,
uint nSeason )
{
ArtworkMap map = GetArtwork(sInetref, nSeason);
for (ArtworkMap::const_iterator i = map.begin();
i != map.end(); ++i)
{
DTC::ArtworkInfo *pArtInfo = pArtworkInfoList->AddNewArtworkInfo();
pArtInfo->setFileName(i.value().url);
switch (i.key())
{
case kArtworkFanart:
pArtInfo->setStorageGroup("Fanart");
pArtInfo->setType("fanart");
pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
"&FileName=%2").arg("Fanart")
.arg(QUrl(i.value().url).path()));
break;
case kArtworkBanner:
pArtInfo->setStorageGroup("Banners");
pArtInfo->setType("banner");
pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
"&FileName=%2").arg("Fanart")
.arg(QUrl(i.value().url).path()));
break;
case kArtworkCoverart:
default:
pArtInfo->setStorageGroup("Coverart");
pArtInfo->setType("coverart");
pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
"&FileName=%2").arg("Fanart")
.arg(QUrl(i.value().url).path()));
break;
}
}
}
void LookerUpper::HandleAllArtwork(bool aggressive)
{
m_updateartwork = true;
if (aggressive)
m_updaterules = true;
// First, handle all recording rules w/ inetrefs
vector<ProgramInfo *> recordingList;
RemoteGetAllScheduledRecordings(recordingList);
int maxartnum = 3;
for( int n = 0; n < (int)recordingList.size(); n++)
{
ProgramInfo *pginfo = new ProgramInfo(*(recordingList[n]));
bool dolookup = true;
if (pginfo->GetInetRef().isEmpty())
dolookup = false;
if (dolookup || aggressive)
{
ArtworkMap map = GetArtwork(pginfo->GetInetRef(), pginfo->GetSeason(), true);
if (map.isEmpty() || (aggressive && map.count() < maxartnum))
{
QString msg = QString("Looking up artwork for recording rule: %1 %2")
.arg(pginfo->GetTitle())
.arg(pginfo->GetSubtitle());
LOG(VB_GENERAL, LOG_INFO, msg);
m_busyRecList.append(pginfo);
m_metadataFactory->Lookup(pginfo, true, true, true);
continue;
}
}
delete pginfo;
}
// Now, Attempt to fill in the gaps for recordings
QMap< QString, ProgramInfo* > recMap;
QMap< QString, uint32_t > inUseMap = ProgramInfo::QueryInUseMap();
QMap< QString, bool > isJobRunning = ProgramInfo::QueryJobsRunning(JOB_COMMFLAG);
ProgramList progList;
LoadFromRecorded( progList, false, inUseMap, isJobRunning, recMap, -1 );
for( int n = 0; n < (int)progList.size(); n++)
{
ProgramInfo *pginfo = new ProgramInfo(*(progList[n]));
bool dolookup = true;
LookupType type = GuessLookupType(pginfo);
if (type == kProbableMovie)
maxartnum = 2;
if ((!aggressive && type == kProbableGenericTelevision) ||
pginfo->GetRecordingGroup() == "Deleted" ||
pginfo->GetRecordingGroup() == "LiveTV")
dolookup = false;
if (dolookup || aggressive)
{
ArtworkMap map = GetArtwork(pginfo->GetInetRef(), pginfo->GetSeason(), true);
if (map.isEmpty() || (aggressive && map.count() < maxartnum))
{
QString msg = QString("Looking up artwork for recording: %1 %2")
.arg(pginfo->GetTitle())
.arg(pginfo->GetSubtitle());
LOG(VB_GENERAL, LOG_INFO, msg);
m_busyRecList.append(pginfo);
m_metadataFactory->Lookup(pginfo, true, true, aggressive);
continue;
}
}
delete pginfo;
}
}
void MetadataFactory::OnVideoResult(MetadataLookup *lookup)
{
if (!lookup)
return;
VideoMetadata *metadata = qVariantValue<VideoMetadata *>(lookup->GetData());
if (!metadata)
return;
metadata->SetTitle(lookup->GetTitle());
metadata->SetSubtitle(lookup->GetSubtitle());
if (metadata->GetTagline().isEmpty())
metadata->SetTagline(lookup->GetTagline());
if (metadata->GetYear() == 1895 || metadata->GetYear() == 0)
metadata->SetYear(lookup->GetYear());
if (metadata->GetReleaseDate() == QDate())
metadata->SetReleaseDate(lookup->GetReleaseDate());
if (metadata->GetDirector() == VIDEO_DIRECTOR_UNKNOWN ||
metadata->GetDirector().isEmpty())
{
QList<PersonInfo> director = lookup->GetPeople(kPersonDirector);
if (director.count() > 0)
metadata->SetDirector(director.takeFirst().name);
}
if (metadata->GetStudio().isEmpty())
{
QStringList studios = lookup->GetStudios();
if (studios.count() > 0)
metadata->SetStudio(studios.takeFirst());
}
if (metadata->GetPlot() == VIDEO_PLOT_DEFAULT ||
metadata->GetPlot().isEmpty())
metadata->SetPlot(lookup->GetDescription());
if (metadata->GetUserRating() == 0)
metadata->SetUserRating(lookup->GetUserRating());
if (metadata->GetRating() == VIDEO_RATING_DEFAULT)
metadata->SetRating(lookup->GetCertification());
if (metadata->GetLength() == 0)
metadata->SetLength(lookup->GetRuntime());
if (metadata->GetSeason() == 0)
metadata->SetSeason(lookup->GetSeason());
if (metadata->GetEpisode() == 0)
metadata->SetEpisode(lookup->GetEpisode());
if (metadata->GetHomepage().isEmpty())
metadata->SetHomepage(lookup->GetHomepage());
metadata->SetInetRef(lookup->GetInetref());
// m_d->AutomaticParentalAdjustment(metadata);
// Cast
QList<PersonInfo> actors = lookup->GetPeople(kPersonActor);
QList<PersonInfo> gueststars = lookup->GetPeople(kPersonGuestStar);
for (QList<PersonInfo>::const_iterator p = gueststars.begin();
p != gueststars.end(); ++p)
{
actors.append(*p);
}
VideoMetadata::cast_list cast;
QStringList cl;
for (QList<PersonInfo>::const_iterator p = actors.begin();
p != actors.end(); ++p)
{
cl.append((*p).name);
}
for (QStringList::const_iterator p = cl.begin();
p != cl.end(); ++p)
{
QString cn = (*p).trimmed();
if (cn.length())
{
cast.push_back(VideoMetadata::cast_list::
value_type(-1, cn));
}
}
metadata->SetCast(cast);
// Genres
VideoMetadata::genre_list video_genres;
QStringList genres = lookup->GetCategories();
for (QStringList::const_iterator p = genres.begin();
p != genres.end(); ++p)
{
QString genre_name = (*p).trimmed();
if (genre_name.length())
{
video_genres.push_back(
VideoMetadata::genre_list::value_type(-1, genre_name));
}
}
metadata->SetGenres(video_genres);
// Countries
VideoMetadata::country_list video_countries;
QStringList countries = lookup->GetCountries();
for (QStringList::const_iterator p = countries.begin();
p != countries.end(); ++p)
{
QString country_name = (*p).trimmed();
if (country_name.length())
{
video_countries.push_back(
VideoMetadata::country_list::value_type(-1,
country_name));
}
}
metadata->SetCountries(video_countries);
ArtworkMap map = lookup->GetDownloads();
QUrl coverurl(map.value(kArtworkCoverart).url);
if (!coverurl.path().isEmpty())
metadata->SetCoverFile(coverurl.path().remove(0,1));
QUrl fanarturl(map.value(kArtworkFanart).url);
if (!fanarturl.path().isEmpty())
metadata->SetFanart(fanarturl.path().remove(0,1));
QUrl bannerurl(map.value(kArtworkBanner).url);
if (!bannerurl.path().isEmpty())
metadata->SetBanner(bannerurl.path().remove(0,1));
QUrl sshoturl(map.value(kArtworkScreenshot).url);
if (!sshoturl.path().isEmpty())
metadata->SetScreenshot(sshoturl.path().remove(0,1));
metadata->SetProcessed(true);
metadata->UpdateDatabase();
if (gCoreContext->HasGUI() && m_parent)
{
QCoreApplication::postEvent(m_parent,
new MetadataFactorySingleResult(lookup));
}
else
{
lookup->deleteLater();
}
}
bool SetArtwork(const QString &inetref,
uint season,
const QString &host,
const ArtworkMap map)
{
if (inetref.isEmpty())
return false;
QString coverart, fanart, banner;
QUrl coverurl(map.value(kArtworkCoverart).url);
if (!coverurl.path().isEmpty())
{
coverart = coverurl.path();
coverart = coverart.remove(0,1);
}
QUrl fanarturl(map.value(kArtworkFanart).url);
if (!fanarturl.path().isEmpty())
{
fanart = fanarturl.path();
fanart = fanart.remove(0,1);
}
QUrl bannerurl(map.value(kArtworkBanner).url);
if (!bannerurl.path().isEmpty())
{
banner = bannerurl.path();
banner = banner.remove(0,1);
}
// Have to delete the old row for this item
MSqlQuery prequery(MSqlQuery::InitCon());
prequery.prepare("DELETE FROM recordedartwork WHERE "
"inetref = :INETREF AND season = :SEASON;");
prequery.bindValue(":INETREF", inetref);
prequery.bindValue(":SEASON", season);
if (!prequery.exec())
{
MythDB::DBError("SetArtwork DELETE FROM", prequery);
return false;
}
// Now we can insert the new
MSqlQuery query(MSqlQuery::InitCon());
query.prepare("INSERT INTO recordedartwork(inetref,"
"season,host,coverart,fanart,banner) VALUES( "
":INETREF, :SEASON, :HOST, :COVERART, "
":FANART, :BANNER);");
query.bindValue(":INETREF", inetref);
query.bindValue(":SEASON", season);
query.bindValue(":HOST", host);
query.bindValue(":COVERART", coverart);
query.bindValue(":FANART", fanart);
query.bindValue(":BANNER", banner);
if (!query.exec())
{
MythDB::DBError("SetArtwork INSERT INTO", query);
return false;
}
return true;
}