frodovdr/vdr-plugin-scraper2vdr
1
0
Fork 0
mirror of https://projects.vdr-developer.org/git/vdr-plugin-scraper2vdr.git synced 2023-10-19 17:58:31 +02:00
Code Issues Releases Wiki Activity
ee4b10b89e
vdr-plugin-scraper2vdr/update.c

1329 lines
50 KiB
C
Raw Normal View History

initial commit
2014-04-12 17:10:43 +02:00
#define __STL_CONFIG_H
#include <locale.h>
#include <vdr/videodir.h>
#include <vdr/tools.h>
#include <vdr/plugin.h>
#include "config.h"
#include "tools.h"
#include "update.h"
extern cScraper2VdrConfig config;
cUpdate::cUpdate(cScrapManager *manager) : cThread("update thread started") {
connection = NULL;
vdrDb = NULL;
tEvents = NULL;
tSeries = NULL;
tEpisodes = NULL;
tSeriesMedia = NULL;
tSeriesActors = NULL;
tMovies = NULL;
tMovieActor = NULL;
tMovieActors = NULL;
tMovieMedia = NULL;
tRecordings = NULL;
scrapManager = manager;
imgPathSeries = config.imageDir + "/series";
imgPathMovies = config.imageDir + "/movies";
lastScrap = 0;
forceUpdate = false;
forceRecordingUpdate = false;
forceVideoDirUpdate = false;
forceScrapInfoUpdate = false;
forceCleanupRecordingDb = false;
char* lang;
lang = setlocale(LC_CTYPE, 0);
if (lang) {
tell(0, "Set locale to '%s'", lang);
if ((strcasestr(lang, "UTF-8") != 0) || (strcasestr(lang, "UTF8") != 0)){
tell(0, "detected UTF-8");
withutf8 = yes;
}
} else {
tell(0, "Reseting locale for LC_CTYPE failed.");
}
cDbConnection::setEncoding(withutf8 ? "utf8": "latin1");
cDbConnection::setHost(config.mysqlHost.c_str());
cDbConnection::setPort(config.mysqlPort);
cDbConnection::setName(config.mysqlDBName.c_str());
cDbConnection::setUser(config.mysqlDBUser.c_str());
cDbConnection::setPass(config.mysqlDBPass.c_str());
cDbTable::setConfPath(cPlugin::ConfigDirectory("epg2vdr/"));
}
cUpdate::~cUpdate() {
if (loopActive)
Stop();
if (vdrDb)
delete vdrDb;
if (tEvents)
delete tEvents;
if (tSeries)
delete tSeries;
if (tEpisodes)
tEpisodes;
if (tSeriesMedia)
delete tSeriesMedia;
if (tSeriesActors)
delete tSeriesActors;
if (tMovies)
delete tMovies;
if (tMovieActor)
delete tMovieActor;
if (tMovieActors)
delete tMovieActors;
if (tMovieMedia)
delete tMovieMedia;
if (tRecordings)
delete tRecordings;
exitDb();
}
int cUpdate::initDb() {
int status = success;
if (!connection)
connection = new cDbConnection();
if (!connection)
return fail;
vdrDb = new cTableVdrs(connection);
if (vdrDb->open() != success)
return fail;
tEvents = new cTableEvents(connection);
if (tEvents->open() != success)
return fail;
tSeries = new cTableSeries(connection);
if (tSeries->open() != success)
return fail;
tEpisodes = new cTableSeriesEpisode(connection);
if (tEpisodes->open() != success)
return fail;
tSeriesMedia = new cTableSeriesMedia(connection);
if (tSeriesMedia->open() != success)
return fail;
tSeriesActors = new cTableSeriesActor(connection);
if (tSeriesActors->open() != success)
return fail;
tMovies = new cTableMovies(connection);
if (tMovies->open() != success)
return fail;
tMovieActor = new cTableMovieActor(connection);
if (tMovieActor->open() != success)
return fail;
tMovieActors = new cTableMovieActors(connection);
if (tMovieActors->open() != success)
return fail;
tMovieMedia = new cTableMovieMedia(connection);
if (tMovieMedia->open() != success)
return fail;
tRecordings = new cTableRecordings(connection);
if (tRecordings->open() != success)
return fail;
return status;
}
int cUpdate::exitDb() {
delete connection;
connection = 0;
return done;
}
void cUpdate::Stop() {
loopActive = false;
waitCondition.Broadcast();
Cancel(3);
}
int cUpdate::CheckConnection(int& timeout) {
static int retry = 0;
timeout = retry < 5 ? 10 : 60;
// check connection
if (!dbConnected(yes)) {
// try to connect
tell(0, "Trying to re-connect to database!");
retry++;
if (initDb() != success) {
tell(0, "Retry #%d failed, retrying in %d seconds!", retry, timeout);
exitDb();
return fail;
}
retry = 0;
tell(0, "Connection established successfull!");
}
return success;
}
bool cUpdate::CheckEpgdBusy(void) {
vdrDb->clear();
vdrDb->setValue(cTableVdrs::fiUuid, EPGDNAME);
if (vdrDb->find()) {
Es::State epgdState = cEpgdState::toState(vdrDb->getStrValue(cTableVdrs::fiState));
if (epgdState >= cEpgdState::esBusy)
return true;
}
return false;
}
int cUpdate::ReadScrapedEvents(void) {
int status = success;
cDbStatement *select = new cDbStatement(tEvents);
select->build("select ");
select->bind(cTableEvents::fiEventId, cDBS::bndOut);
select->bind(cTableEvents::fiChannelId, cDBS::bndOut, ", ");
select->bind(cTableEvents::fiUseId, cDBS::bndOut, ", ");
select->bind(cTableEvents::fiScrSeriesId, cDBS::bndOut, ", ");
select->bind(cTableEvents::fiScrSeriesEpisode, cDBS::bndOut, ", ");
select->bind(cTableEvents::fiScrMovieId, cDBS::bndOut, ", ");
select->bind(cTableEvents::fiScrSp, cDBS::bndOut, ", ");
select->build(" from %s where ", tEvents->TableName());
select->build(" ((%s is not null and %s > 0) ",
tEvents->getField(cTableEvents::fiScrSeriesId)->name,
tEvents->getField(cTableEvents::fiScrSeriesId)->name);
select->build(" or (%s is not null and %s > 0)) ",
tEvents->getField(cTableEvents::fiScrMovieId)->name,
tEvents->getField(cTableEvents::fiScrMovieId)->name);
if (lastScrap > 0) {
select->build(" and %s > %d",
tEvents->getField(cTableEvents::fiScrSp)->name,
lastScrap);
}
status += select->prepare();
if (status != success) {
delete select;
return 0;
}
int eventId = 0;
int seriesId = 0;
int episodeId = 0;
int movieId = 0;
string channelId = "";
int numNew = 0;
for (int res = select->find(); res; res = select->fetch()) {
eventId = tEvents->getIntValue(cTableEvents::fiUseId);
channelId = tEvents->getStrValue(cTableEvents::fiChannelId);
seriesId = tEvents->getIntValue(cTableEvents::fiScrSeriesId);
episodeId = tEvents->getIntValue(cTableEvents::fiScrSeriesEpisode);
movieId = tEvents->getIntValue(cTableEvents::fiScrMovieId);
scrapManager->AddEvent(eventId, channelId, seriesId, episodeId, movieId);
lastScrap = max(lastScrap, (int)tEvents->getIntValue(cTableEvents::fiScrSp));
numNew++;
}
select->freeResult();
delete select;
return numNew;
}
//***************************************************************************
// SERIES
//***************************************************************************
int cUpdate::ReadSeries(bool isRec) {
scrapManager->InitIterator(isRec);
int seriesId = 0;
int episodeId = 0;
if (!CreateDirectory(config.imageDir))
return 0;
if (!CreateDirectory(imgPathSeries))
return 0;
bool isNew = false;
int numNew = 0;
while (scrapManager->GetNextSeries(isRec, seriesId, episodeId)) {
cTVDBSeries *series = scrapManager->GetSeries(seriesId);
if (!series) {
tSeries->clear();
tSeries->setValue(cTableSeries::fiSeriesId, seriesId);
int res = tSeries->find();
if (res) {
series = scrapManager->AddSeries(tSeries);
}
isNew = true;
} else {
isNew = false;
}
if (series) {
stringstream sPath;
sPath << imgPathSeries << "/" << seriesId;
string seriesPath = sPath.str();
if (episodeId) {
ReadEpisode(episodeId, series, seriesPath);
}
if (isNew) {
ReadSeriesActors(series, seriesPath);
LoadSeriesMedia(series, seriesPath);
}
}
numNew++;
}
return numNew;
}
void cUpdate::ReadEpisode(int episodeId, cTVDBSeries *series, string path) {
int status = success;
tEpisodes->clear();
tEpisodes->setValue(cTableSeriesEpisode::fiEpisodeId, episodeId);
cDbStatement *selectEpisode = new cDbStatement(tEpisodes);
selectEpisode->build("select ");
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeName, cDBS::bndOut);
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeNumber, cDBS::bndOut, ", ");
selectEpisode->bind(cTableSeriesEpisode::fiSeasonNumber, cDBS::bndOut, ", ");
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeOverview, cDBS::bndOut, ", ");
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeFirstAired, cDBS::bndOut, ", ");
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeGuestStars, cDBS::bndOut, ", ");
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeRating, cDBS::bndOut, ", ");
selectEpisode->build(" from %s where ", tEpisodes->TableName());
selectEpisode->bind(cTableSeriesEpisode::fiEpisodeId, cDBS::bndIn | cDBS::bndSet);
status += selectEpisode->prepare();
if (status != success) {
delete selectEpisode;
return;
}
int res = selectEpisode->find();
if (res) {
scrapManager->AddSeriesEpisode(series, tEpisodes);
LoadEpisodeImage(series, episodeId, path);
int season = tEpisodes->getIntValue(cTableSeriesEpisode::fiSeasonNumber);
if (season > 0)
LoadSeasonPoster(series, season, path);
}
selectEpisode->freeResult();
delete selectEpisode;
return;
}
void cUpdate::LoadEpisodeImage(cTVDBSeries *series, int episodeId, string path) {
int status = success;
stringstream iPath;
iPath << path << "/" << "episode_" << episodeId << ".jpg";
string imgPath = iPath.str();
bool imgExists = FileExists(imgPath);
if (!CreateDirectory(path))
return;
tSeriesMedia->clear();
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
cDbStatement *selectImg = new cDbStatement(tSeriesMedia);
selectImg->build("select ");
selectImg->bind(cTableSeriesMedia::fiMediaWidth, cDBS::bndOut);
selectImg->bind(cTableSeriesMedia::fiMediaHeight, cDBS::bndOut, ", ");
if (!imgExists) {
selectImg->bind(cTableSeriesMedia::fiMediaContent, cDBS::bndOut, ", ");
selectImg->build(", length(");
selectImg->bind(&imageSize, cDBS::bndOut);
selectImg->build(")");
}
selectImg->build(" from %s where ", tSeriesMedia->TableName());
selectImg->bind(cTableSeriesMedia::fiSeriesId, cDBS::bndIn | cDBS::bndSet);
selectImg->bind(cTableSeriesMedia::fiEpisodeId, cDBS::bndIn | cDBS::bndSet, " and ");
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return;
}
tSeriesMedia->setValue(cTableSeriesMedia::fiSeriesId, series->id);
tSeriesMedia->setValue(cTableSeriesMedia::fiEpisodeId, episodeId);
int res = selectImg->find();
if (res) {
if (!imgExists) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(imgPath.c_str(), "w")) {
fwrite(tSeriesMedia->getStrValue(cTableSeriesMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
}
int imgWidth = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaWidth);
int imgHeight = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaHeight);
series->InsertEpisodeImage(episodeId, imgWidth, imgHeight, imgPath);
}
selectImg->freeResult();
delete selectImg;
}
void cUpdate::LoadSeasonPoster(cTVDBSeries *series, int season, string path) {
int status = success;
stringstream iPath;
iPath << path << "/" << "season_" << season << ".jpg";
stringstream tPath;
tPath << path << "/" << "season_" << season << "_thumb.jpg";
string imgPath = iPath.str();
string thumbPath = tPath.str();
bool imgExists = FileExists(imgPath);
if (!CreateDirectory(path))
return;
tSeriesMedia->clear();
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
cDbStatement *selectImg = new cDbStatement(tSeriesMedia);
selectImg->build("select ");
selectImg->bind(cTableSeriesMedia::fiMediaWidth, cDBS::bndOut);
selectImg->bind(cTableSeriesMedia::fiMediaHeight, cDBS::bndOut, ", ");
if (!imgExists) {
selectImg->bind(cTableSeriesMedia::fiMediaContent, cDBS::bndOut, ", ");
selectImg->build(", length(");
selectImg->bind(&imageSize, cDBS::bndOut);
selectImg->build(")");
}
selectImg->build(" from %s where ", tSeriesMedia->TableName());
selectImg->bind(cTableSeriesMedia::fiSeriesId, cDBS::bndIn | cDBS::bndSet);
selectImg->bind(cTableSeriesMedia::fiSeasonNumber, cDBS::bndIn | cDBS::bndSet, " and ");
selectImg->bind(cTableSeriesMedia::fiMediaType, cDBS::bndIn | cDBS::bndSet, " and ");
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return;
}
tSeriesMedia->setValue(cTableSeriesMedia::fiSeriesId, series->id);
tSeriesMedia->setValue(cTableSeriesMedia::fiSeasonNumber, season);
tSeriesMedia->setValue(cTableSeriesMedia::fiMediaType, msSeasonPoster);
int res = selectImg->find();
if (res) {
if (!imgExists) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(imgPath.c_str(), "w")) {
fwrite(tSeriesMedia->getStrValue(cTableSeriesMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
}
int imgWidth = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaWidth);
int imgHeight = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaHeight);
if (!FileExists(thumbPath)) {
CreateThumbnail(imgPath, thumbPath, imgWidth, imgHeight, 2);
}
series->InsertMedia(msSeasonPoster, imgWidth, imgHeight, imgPath, season);
series->InsertMedia(msSeasonPosterThumb, imgWidth/2, imgHeight/2, thumbPath, season);
}
selectImg->freeResult();
delete selectImg;
}
void cUpdate::ReadSeriesActors(cTVDBSeries *series, string path) {
int status = success;
tSeriesActors->clear();
cDbValue series_id;
series_id.setField(tSeriesMedia->getField(cTableSeriesMedia::fiSeriesId));
series_id.setValue(series->id);
cDbStatement *selectActors = new cDbStatement(tSeriesActors);
selectActors->build("select ");
selectActors->setBindPrefix("series_actor.");
selectActors->bind(cTableSeriesActor::fiActorId, cDBS::bndOut);
selectActors->bind(cTableSeriesActor::fiActorName, cDBS::bndOut, ", ");
selectActors->bind(cTableSeriesActor::fiActorRole, cDBS::bndOut, ", ");
selectActors->clrBindPrefix();
selectActors->build(" from %s, %s where ", tSeriesActors->TableName(), tSeriesMedia->TableName());
selectActors->build(" %s.%s = %s.%s ", tSeriesActors->TableName(),
tSeriesActors->getField(cTableSeriesActor::fiActorId)->name,
tSeriesMedia->TableName(),
tSeriesMedia->getField(cTableSeriesMedia::fiActorId)->name);
selectActors->setBindPrefix("series_media.");
selectActors->bind(&series_id, cDBS::bndIn | cDBS::bndSet, " and ");
selectActors->build(" order by %s, %s asc", tSeriesActors->getField(cTableSeriesActor::fiSortOrder)->name,
tSeriesActors->getField(cTableSeriesActor::fiActorRole)->name);
status += selectActors->prepare();
if (status != success) {
delete selectActors;
return;
}
for (int res = selectActors->find(); res; res = selectActors->fetch()) {
scrapManager->AddSeriesActor(series, tSeriesActors);
LoadSeriesActorThumb(series, tSeriesActors->getIntValue(cTableSeriesActor::fiActorId), path);
}
selectActors->freeResult();
delete selectActors;
}
void cUpdate::LoadSeriesActorThumb(cTVDBSeries *series, int actorId, string path) {
int status = success;
stringstream iPath;
iPath << path << "/" << "actor_" << actorId << ".jpg";
string imgPath = iPath.str();
bool imgExists = FileExists(imgPath);
if (!CreateDirectory(path))
return;
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
tSeriesMedia->clear();
cDbStatement *selectActorThumbs = new cDbStatement(tSeriesMedia);
selectActorThumbs->build("select ");
selectActorThumbs->bind(cTableSeriesMedia::fiMediaWidth, cDBS::bndOut);
selectActorThumbs->bind(cTableSeriesMedia::fiMediaHeight, cDBS::bndOut, ", ");
if (!imgExists) {
selectActorThumbs->bind(cTableSeriesMedia::fiMediaContent, cDBS::bndOut, ", ");
selectActorThumbs->build(", length(");
selectActorThumbs->bind(&imageSize, cDBS::bndOut);
selectActorThumbs->build(")");
}
selectActorThumbs->build(" from %s where ", tSeriesMedia->TableName());
selectActorThumbs->bind(cTableSeriesMedia::fiActorId, cDBS::bndIn | cDBS::bndSet);
status += selectActorThumbs->prepare();
if (status != success) {
delete selectActorThumbs;
return;
}
tSeriesMedia->setValue(cTableSeriesMedia::fiActorId, actorId);
int res = selectActorThumbs->find();
if (res) {
if (!imgExists) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(imgPath.c_str(), "w")) {
fwrite(tSeriesMedia->getStrValue(cTableSeriesMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
}
int tmbWidth = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaWidth);
int tmbHeight = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaHeight);
series->InsertActorThumb(actorId, tmbWidth, tmbHeight, imgPath);
}
selectActorThumbs->freeResult();
delete selectActorThumbs;
}
void cUpdate::LoadSeriesMedia(cTVDBSeries *series, string path) {
int status = success;
tSeriesMedia->clear();
cDbStatement *selectImg = new cDbStatement(tSeriesMedia);
selectImg->build("select ");
selectImg->bind(cTableSeriesMedia::fiMediaWidth, cDBS::bndOut);
selectImg->bind(cTableSeriesMedia::fiMediaHeight, cDBS::bndOut, ", ");
selectImg->bind(cTableSeriesMedia::fiMediaType, cDBS::bndOut, ", ");
selectImg->build(" from %s where ", tSeriesMedia->TableName());
selectImg->bind(cTableSeriesMedia::fiSeriesId, cDBS::bndIn | cDBS::bndSet);
selectImg->build(" and %s in (%d, %d, %d, %d, %d, %d, %d, %d, %d)",
tSeriesMedia->getField(cTableSeriesMedia::fiMediaType)->name,
msPoster1, msPoster2, msPoster3,
msFanart1, msFanart2, msFanart3,
msBanner1, msBanner2, msBanner3);
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return;
}
tSeriesMedia->setValue(cTableSeriesMedia::fiSeriesId, series->id);
for (int res = selectImg->find(); res; res = selectImg->fetch()) {
int mediaType = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaType);
int mediaWidth = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaWidth);
int mediaHeight = tSeriesMedia->getIntValue(cTableSeriesMedia::fiMediaHeight);
string mediaPath = LoadMediaSeries(series->id, mediaType, path, mediaWidth, mediaHeight);
series->InsertMedia(mediaType, mediaWidth, mediaHeight, mediaPath);
if (mediaType == msPoster1) {
string thumbPath = path + "/poster_thumb.jpg";
series->InsertMedia(msPosterThumb, mediaWidth/5, mediaHeight/5, thumbPath);
}
}
selectImg->freeResult();
delete selectImg;
}
string cUpdate::LoadMediaSeries(int seriesId, int mediaType, string path, int width, int height) {
int status = success;
stringstream iPath;
iPath << path << "/";
bool createThumb = false;
stringstream tPath;
tPath << path << "/";
switch (mediaType) {
case msPoster1:
iPath << "poster1.jpg";
createThumb = true;
tPath << "poster_thumb.jpg";
break;
case msPoster2:
iPath << "poster2.jpg";
break;
case msPoster3:
iPath << "poster3.jpg";
break;
case msFanart1:
iPath << "fanart1.jpg";
break;
case msFanart2:
iPath << "fanart2.jpg";
break;
case msFanart3:
iPath << "fanart3.jpg";
break;
case msBanner1:
iPath << "banner1.jpg";
break;
case msBanner2:
iPath << "banner2.jpg";
break;
case msBanner3:
iPath << "banner3.jpg";
break;
default:
break;
}
string imgPath = iPath.str();
string thumbPath = tPath.str();
if (FileExists(imgPath)) {
if (createThumb && !FileExists(thumbPath)) {
CreateThumbnail(imgPath, thumbPath, width, height, 5);
}
return imgPath;
}
if (!CreateDirectory(path))
return "";
tSeriesMedia->clear();
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
cDbStatement *selectImg = new cDbStatement(tSeriesMedia);
selectImg->build("select ");
selectImg->bind(cTableSeriesMedia::fiMediaContent, cDBS::bndOut);
selectImg->build(", length(");
selectImg->bind(&imageSize, cDBS::bndOut);
selectImg->build(")");
selectImg->build(" from %s where ", tSeriesMedia->TableName());
selectImg->bind(cTableSeriesMedia::fiSeriesId, cDBS::bndIn | cDBS::bndSet);
selectImg->bind(cTableSeriesMedia::fiMediaType, cDBS::bndIn | cDBS::bndSet, " and ");
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return "";
}
tSeriesMedia->setValue(cTableSeriesMedia::fiSeriesId, seriesId);
tSeriesMedia->setValue(cTableSeriesMedia::fiMediaType, mediaType);
int res = selectImg->find();
if (res) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(imgPath.c_str(), "w")) {
fwrite(tSeriesMedia->getStrValue(cTableSeriesMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
if (createThumb && !FileExists(thumbPath)) {
CreateThumbnail(imgPath, thumbPath, width, height, 5);
}
}
selectImg->freeResult();
delete selectImg;
return imgPath;
}
//***************************************************************************
// MOVIES
//***************************************************************************
int cUpdate::ReadMovies(bool isRec) {
scrapManager->InitIterator(isRec);
int movieId = 0;
int i=0;
if (!CreateDirectory(config.imageDir))
return 0;
if (!CreateDirectory(imgPathMovies))
return 0;
int numNew = 0;
while (scrapManager->GetNextMovie(isRec, movieId)) {
cMovieDbMovie *movie = scrapManager->GetMovie(movieId);
if (movie)
continue;
tMovies->clear();
tMovies->setValue(cTableMovies::fiMovieId, movieId);
int res = tMovies->find();
if (!res)
continue;
movie = scrapManager->AddMovie(tMovies);
stringstream mPath;
mPath << imgPathMovies << "/" << movieId;
string moviePath = mPath.str();
ReadMovieActors(movie);
LoadMovieActorThumbs(movie);
LoadMovieMedia(movie, moviePath);
numNew++;
}
return numNew;
}
void cUpdate::ReadMovieActors(cMovieDbMovie *movie) {
int status = success;
cDbValue actorRole;
cDbValue actorMovie;
cDbValue thbWidth;
cDbValue thbHeight;
actorRole.setField(tMovieActors->getField(cTableMovieActors::fiRole));
actorMovie.setField(tMovieActors->getField(cTableMovieActors::fiMovieId));
thbWidth.setField(tMovieMedia->getField(cTableMovieMedia::fiMediaWidth));
thbHeight.setField(tMovieMedia->getField(cTableMovieMedia::fiMediaHeight));
cDbStatement *selectActors = new cDbStatement(tMovieActor);
selectActors->build("select ");
selectActors->setBindPrefix("act.");
selectActors->bind(cTableMovieActor::fiActorId, cDBS::bndOut);
selectActors->bind(cTableMovieActor::fiActorName, cDBS::bndOut, ", ");
selectActors->setBindPrefix("role.");
selectActors->bind(&actorRole, cDBS::bndOut, ", ");
selectActors->setBindPrefix("thumb.");
selectActors->bind(&thbWidth, cDBS::bndOut, ", ");
selectActors->bind(&thbHeight, cDBS::bndOut, ", ");
selectActors->clrBindPrefix();
selectActors->build(" from %s act, %s role, %s thumb where ",
tMovieActor->TableName(), tMovieActors->TableName(), tMovieMedia->TableName());
selectActors->build("act.%s = role.%s ",
tMovieActor->getField(cTableMovieActor::fiActorId)->name,
tMovieActors->getField(cTableMovieActors::fiActorId)->name);
selectActors->build(" and role.%s = thumb.%s ",
tMovieActors->getField(cTableMovieActors::fiActorId)->name,
tMovieMedia->getField(cTableMovieMedia::fiActorId)->name);
selectActors->setBindPrefix("role.");
selectActors->bind(&actorMovie, cDBS::bndIn | cDBS::bndSet, " and ");
status += selectActors->prepare();
if (status != success) {
delete selectActors;
return;
}
actorMovie.setValue(movie->id);
for (int res = selectActors->find(); res; res = selectActors->fetch()) {
scrapManager->AddMovieActor(movie, tMovieActor, actorRole.getStrValue());
int tmbWidth = thbWidth.getIntValue();
int tmbHeight = thbHeight.getIntValue();
movie->SetActorThumbSize(tMovieActor->getIntValue(cTableMovieActor::fiActorId), tmbWidth, tmbHeight);
}
selectActors->freeResult();
delete selectActors;
}
void cUpdate::LoadMovieActorThumbs(cMovieDbMovie *movie) {
int status = success;
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
tMovieMedia->clear();
cDbStatement *selectActorThumbs = new cDbStatement(tMovieMedia);
selectActorThumbs->build("select ");
selectActorThumbs->bind(cTableMovieMedia::fiMediaContent, cDBS::bndOut);
selectActorThumbs->build(", length(");
selectActorThumbs->bind(&imageSize, cDBS::bndOut);
selectActorThumbs->build(")");
selectActorThumbs->build(" from %s where ", tMovieMedia->TableName());
selectActorThumbs->bind(cTableMovieMedia::fiActorId, cDBS::bndIn | cDBS::bndSet);
status += selectActorThumbs->prepare();
if (status != success) {
delete selectActorThumbs;
return;
}
string movieActorsPath = imgPathMovies + "/actors";
if (!CreateDirectory(movieActorsPath))
return;
vector<int> IDs = movie->GetActorIDs();
for (vector<int>::iterator it = IDs.begin(); it != IDs.end(); it++) {
int actorId = (int)*it;
stringstream tName;
tName << "actor_" << actorId << ".jpg";
string thumbName = tName.str();
string thumbFullPath = movieActorsPath + "/" + thumbName;
if (!FileExists(thumbFullPath)) {
tMovieMedia->setValue(cTableMovieMedia::fiActorId, actorId);
int res = selectActorThumbs->find();
if (res) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(thumbFullPath.c_str(), "w")) {
fwrite(tMovieMedia->getStrValue(cTableMovieMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
movie->SetActorPath(actorId, thumbFullPath);
}
} else {
movie->SetActorPath(actorId, thumbFullPath);
}
}
selectActorThumbs->freeResult();
delete selectActorThumbs;
}
void cUpdate::LoadMovieMedia(cMovieDbMovie *movie, string moviePath) {
int status = success;
tMovieMedia->clear();
cDbStatement *selectImg = new cDbStatement(tMovieMedia);
selectImg->build("select ");
selectImg->bind(cTableMovieMedia::fiMediaWidth, cDBS::bndOut);
selectImg->bind(cTableMovieMedia::fiMediaHeight, cDBS::bndOut, ", ");
selectImg->bind(cTableMovieMedia::fiMediaType, cDBS::bndOut, ", ");
selectImg->build(" from %s where ", tMovieMedia->TableName());
selectImg->bind(cTableMovieMedia::fiMovieId, cDBS::bndIn | cDBS::bndSet);
selectImg->build(" and %s in (%d, %d, %d, %d)",
tMovieMedia->getField(cTableMovieMedia::fiMediaType)->name,
mmPoster,
mmFanart,
mmCollectionPoster,
mmCollectionFanart);
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return;
}
tMovieMedia->setValue(cTableMovieMedia::fiMovieId, movie->id);
for (int res = selectImg->find(); res; res = selectImg->fetch()) {
int mediaType = tMovieMedia->getIntValue(cTableMovieMedia::fiMediaType);
int mediaWidth = tMovieMedia->getIntValue(cTableMovieMedia::fiMediaWidth);
int mediaHeight = tMovieMedia->getIntValue(cTableMovieMedia::fiMediaHeight);
string imgPath = LoadMediaMovie(movie->id, mediaType, moviePath, mediaWidth, mediaHeight);
if (imgPath.size() > 0)
scrapManager->AddMovieMedia(movie, tMovieMedia, imgPath);
if (mediaType == mmPoster) {
cMovieMedia *m = new cMovieMedia();
m->mediaType = mmPosterThumb;
m->width = mediaWidth/4;
m->height = mediaHeight/4;
m->path = moviePath + "/poster_thumb.jpg";
movie->InsertMedia(m);
}
}
selectImg->freeResult();
delete selectImg;
}
string cUpdate::LoadMediaMovie(int movieId, int mediaType, string path, int width, int height) {
int status = success;
stringstream iPath;
iPath << path << "/";
bool createThumb = false;
stringstream tPath;
tPath << path << "/";
switch (mediaType) {
case mmPoster:
iPath << "poster.jpg";
createThumb = true;
tPath << "poster_thumb.jpg";
break;
case mmFanart:
iPath << "fanart.jpg";
break;
case mmCollectionPoster:
iPath << "collectionPoster.jpg";
break;
case mmCollectionFanart:
iPath << "collectionFanart.jpg";
break;
default:
break;
}
string imgPath = iPath.str();
string thumbPath = tPath.str();
if (FileExists(imgPath)) {
if (createThumb && !FileExists(thumbPath)) {
CreateThumbnail(imgPath, thumbPath, width, height, 4);
}
return imgPath;
}
if (!CreateDirectory(path))
return imgPath;
tMovieMedia->clear();
cDbValue imageSize;
cDBS::FieldDef imageSizeDef = { "media_content", cDBS::ffUInt, 0, 999, cDBS::ftData };
imageSize.setField(&imageSizeDef);
cDbStatement *selectImg = new cDbStatement(tMovieMedia);
selectImg->build("select ");
selectImg->bind(cTableMovieMedia::fiMediaContent, cDBS::bndOut);
selectImg->build(", length(");
selectImg->bind(&imageSize, cDBS::bndOut);
selectImg->build(")");
selectImg->build(" from %s where ", tMovieMedia->TableName());
selectImg->bind(cTableMovieMedia::fiMovieId, cDBS::bndIn | cDBS::bndSet);
selectImg->bind(cTableMovieMedia::fiMediaType, cDBS::bndIn | cDBS::bndSet, " and ");
status += selectImg->prepare();
if (status != success) {
delete selectImg;
return "";
}
tMovieMedia->setValue(cTableMovieMedia::fiMovieId, movieId);
tMovieMedia->setValue(cTableMovieMedia::fiMediaType, mediaType);
int res = selectImg->find();
if (res) {
int size = imageSize.getIntValue();
if (FILE* fh = fopen(imgPath.c_str(), "w")) {
fwrite(tMovieMedia->getStrValue(cTableMovieMedia::fiMediaContent), 1, size, fh);
fclose(fh);
}
if (createThumb && !FileExists(thumbPath)) {
CreateThumbnail(imgPath, thumbPath, width, height, 4);
}
}
selectImg->freeResult();
delete selectImg;
return imgPath;
}
//***************************************************************************
// RECORDINGS
//***************************************************************************
int cUpdate::ReadRecordings(void) {
int status = success;
cDbStatement *select = new cDbStatement(tRecordings);
select->build("select ");
select->bind(cTableRecordings::fiRecPath, cDBS::bndOut);
select->bind(cTableRecordings::fiRecStart, cDBS::bndOut, ", ");
select->bind(cTableRecordings::fiMovieId, cDBS::bndOut, ", ");
select->bind(cTableRecordings::fiSeriesId, cDBS::bndOut, ", ");
select->bind(cTableRecordings::fiEpisodeId, cDBS::bndOut, ", ");
select->build(" from %s where ", tRecordings->TableName());
select->bind(cTableRecordings::fiUuid, cDBS::bndIn | cDBS::bndSet);
select->build(" and %s = 0", tRecordings->getField(cTableRecordings::fiScrapNew)->name);
status += select->prepare();
if (status != success) {
delete select;
return 0;
}
tRecordings->clear();
tRecordings->setValue(cTableRecordings::fiUuid, config.uuid.c_str());
int numRecs = 0;
for (int res = select->find(); res; res = select->fetch()) {
int recStart = tRecordings->getIntValue(cTableRecordings::fiRecStart);
string recPath = tRecordings->getStrValue(cTableRecordings::fiRecPath);
int movieId = tRecordings->getIntValue(cTableRecordings::fiMovieId);
int seriesId = tRecordings->getIntValue(cTableRecordings::fiSeriesId);
int episodeId = tRecordings->getIntValue(cTableRecordings::fiEpisodeId);
bool isNew = scrapManager->AddRecording(recStart, recPath, seriesId, episodeId, movieId);
if (isNew)
numRecs++;
}
select->freeResult();
delete select;
return numRecs;
}
int cUpdate::ScanVideoDir(void) {
int newRecs = 0;
for (cRecording *rec = Recordings.First(); rec; rec = Recordings.Next(rec)) {
string recPath = rec->FileName();
int recStart = rec->Start();
if (!scrapManager->RecordingExists(recStart, recPath)) {
newRecs++;
int scrapInfoMovieID = 0;
int scrapInfoSeriesID = 0;
int scrapInfoEpisodeID = 0;
ReadScrapInfo(rec->FileName(), scrapInfoMovieID, scrapInfoSeriesID, scrapInfoEpisodeID);
int eventId = 0;
string channelId = "";
added compatibility to VDR < 2.1.x
2014-04-13 08:17:00 +02:00
string title = rec->Name();
//remove directory
size_t posDelim = title.find_last_of('~');
if (posDelim != string::npos) {
title = title.substr(posDelim+1);
}
initial commit
2014-04-12 17:10:43 +02:00
string subTitle = "";
const cRecordingInfo *recInfo = rec->Info();
if (recInfo) {
const cEvent *recEvent = recInfo->GetEvent();
if (recEvent) {
eventId = recEvent->EventID();
channelId = *(recInfo->ChannelID().ToString());
subTitle = (recInfo->ShortText())?(recInfo->ShortText()):"";
}
}
tRecordings->clear();
tRecordings->setValue(cTableRecordings::fiUuid, config.uuid.c_str());
tRecordings->setValue(cTableRecordings::fiRecPath, recPath.c_str());
tRecordings->setValue(cTableRecordings::fiRecStart, recStart);
tRecordings->setValue(cTableRecordings::fiEventId, eventId);
tRecordings->setValue(cTableRecordings::fiChannelId, channelId.c_str());
tRecordings->setValue(cTableRecordings::fiScrapInfoMovieId, scrapInfoMovieID);
tRecordings->setValue(cTableRecordings::fiScrapInfoSeriesId, scrapInfoSeriesID);
tRecordings->setValue(cTableRecordings::fiScrapInfoEpisodeId, scrapInfoEpisodeID);
tRecordings->setValue(cTableRecordings::fiScrapNew, 1);
tRecordings->setValue(cTableRecordings::fiRecTitle, title.c_str());
tRecordings->setValue(cTableRecordings::fiRecSubTitle, subTitle.c_str());
tRecordings->setValue(cTableRecordings::fiRecDuration, rec->LengthInSeconds()/60);
tRecordings->store();
}
}
return newRecs;
}
int cUpdate::ScanVideoDirScrapInfo(void) {
int numUpdated = 0;
for (cRecording *rec = Recordings.First(); rec; rec = Recordings.Next(rec)) {
int recStart = rec->Start();
string recPath = rec->FileName();
bool recExists = LoadRecording(recStart, recPath);
int scrapInfoMovieID = 0;
int scrapInfoSeriesID = 0;
int scrapInfoEpisodeID = 0;
ReadScrapInfo(rec->FileName(), scrapInfoMovieID, scrapInfoSeriesID, scrapInfoEpisodeID);
if (ScrapInfoChanged(scrapInfoMovieID, scrapInfoSeriesID, scrapInfoEpisodeID)) {
tRecordings->setValue(cTableRecordings::fiScrapNew, 1);
tRecordings->setValue(cTableRecordings::fiScrapInfoMovieId, scrapInfoMovieID);
tRecordings->setValue(cTableRecordings::fiScrapInfoSeriesId, scrapInfoSeriesID);
tRecordings->setValue(cTableRecordings::fiScrapInfoEpisodeId, scrapInfoEpisodeID);
tRecordings->update();
numUpdated++;
}
}
return numUpdated;
}
bool cUpdate::LoadRecording(int recStart, string recPath) {
tRecordings->clear();
tRecordings->setValue(cTableRecordings::fiUuid, config.uuid.c_str());
tRecordings->setValue(cTableRecordings::fiRecStart, recStart);
tRecordings->setValue(cTableRecordings::fiRecPath, recPath.c_str());
int found = tRecordings->find();
if (found == yes) {
return true;
}
return false;
}
bool cUpdate::ScrapInfoChanged(int scrapInfoMovieID, int scrapInfoSeriesID, int scrapInfoEpisodeID) {
int movieIdCurrent = tRecordings->getIntValue(cTableRecordings::fiScrapInfoMovieId);
int seriesIdCurrent = tRecordings->getIntValue(cTableRecordings::fiScrapInfoSeriesId);
int episodeIdCurrent = tRecordings->getIntValue(cTableRecordings::fiScrapInfoEpisodeId);
if ((movieIdCurrent != scrapInfoMovieID) ||
(seriesIdCurrent != scrapInfoSeriesID) ||
(episodeIdCurrent != scrapInfoEpisodeID))
return true;
return false;
}
void cUpdate::ReadScrapInfo(string recDir, int &scrapInfoMovieID, int &scrapInfoSeriesID, int &scrapInfoEpisodeID) {
stringstream sInfoName;
sInfoName << recDir << "/" << config.recScrapInfoName;
string scrapInfoName = sInfoName.str();
if (!FileExists(scrapInfoName, false)) {
string twoHigher = TwoFoldersHigher(recDir);
if (twoHigher.size() > 0) {
stringstream sInfoNameAlt;
sInfoNameAlt << twoHigher << "/" << config.recScrapInfoName;
scrapInfoName = sInfoNameAlt.str();
if (!FileExists(scrapInfoName, false)) {
return;
}
} else
return;
}
vector<string> scrapInfoLines;
FILE *f = fopen(scrapInfoName.c_str(), "r");
if (!f)
return;
cReadLine ReadLine;
char *line;
while ((line = ReadLine.Read(f)) != NULL) {
scrapInfoLines.push_back(line);
}
fclose(f);
int numLines = scrapInfoLines.size();
if (numLines < 2) {
tell(0, "invalid scrapinfo file in %s", recDir.c_str());
return;
}
for (int line=0; line < numLines; line++) {
scrapInfoLines[line] = trim(scrapInfoLines[line]);
toLower(scrapInfoLines[line]);
}
bool isMovie = false;
bool isSeries = false;
if (!scrapInfoLines[0].compare("movie"))
isMovie = true;
else if (!scrapInfoLines[0].compare("series"))
isSeries = true;
else
tell(0, "invalid scrapinfo file in %s", recDir.c_str());
int id1 = 0, id2 = 0;
string key = "", value = "";
splitstring s(scrapInfoLines[1].c_str());
vector<string> flds = s.split('=');
if (flds.size() == 2) {
key = trim(flds[0]);
value = trim(flds[1]);
} else {
tell(0, "invalid scrapinfo file in %s", recDir.c_str());
}
if (!key.compare("id")) {
id1 = atoi(value.c_str());
if (numLines > 2) {
splitstring s2(scrapInfoLines[2].c_str());
vector<string> flds2 = s2.split('=');
if (flds2.size() == 2) {
key = trim(flds2[0]);
toLower(key);
value = trim(flds2[1]);
}
if (!key.compare("episode")) {
id2 = atoi(value.c_str());
}
}
} else
tell(0, "invalid scrapinfo file in %s", recDir.c_str());
if (isSeries) {
scrapInfoSeriesID = id1;
scrapInfoEpisodeID = id2;
}
if (isMovie) {
scrapInfoMovieID = id1;
}
}
//***************************************************************************
// Cleanup
//***************************************************************************
int cUpdate::CleanupSeries(void) {
//read existing series in file system
vector<string> storedSeries;
DIR *dir;
struct dirent *entry;
if ((dir = opendir (imgPathSeries.c_str())) != NULL) {
while ((entry = readdir (dir)) != NULL) {
string dirName = entry->d_name;
if (isNumber(dirName)) {
storedSeries.push_back(dirName);
}
}
closedir (dir);
} else return 0;
int deletedSeries = 0;
//aviod complete delete if no series are available
int numSeriesAvailable = scrapManager->GetNumSeries();
if (numSeriesAvailable == 0)
return 0;
for (vector<string>::iterator seriesDir = storedSeries.begin(); seriesDir != storedSeries.end(); seriesDir++) {
int seriesId = atoi(((string)*seriesDir).c_str());
if (!scrapManager->SeriesInUse(seriesId)) {
string delDir = imgPathSeries + "/" + ((string)*seriesDir);
DeleteDirectory(delDir);
deletedSeries++;
}
}
return deletedSeries;
}
int cUpdate::CleanupMovies(void) {
//read existing movies in file system
vector<string> storedMovies;
DIR *dir;
struct dirent *entry;
if ((dir = opendir (imgPathMovies.c_str())) != NULL) {
while ((entry = readdir (dir)) != NULL) {
string dirName = entry->d_name;
if (isNumber(dirName)) {
storedMovies.push_back(dirName);
}
}
closedir (dir);
} else return 0;
int deletedMovies = 0;
//aviod complete delete if no movies are available
int numMoviesAvailable = scrapManager->GetNumMovies();
if (numMoviesAvailable == 0)
return 0;
for (vector<string>::iterator movieDir = storedMovies.begin(); movieDir != storedMovies.end(); movieDir++) {
int movieId = atoi(((string)*movieDir).c_str());
if (!scrapManager->MovieInUse(movieId)) {
string delDir = imgPathMovies + "/" + ((string)*movieDir);
DeleteDirectory(delDir);
deletedMovies++;
}
}
return deletedMovies;
}
int cUpdate::CleanupRecordings(void) {
//delete all not anymore existing recordings in database
int status = success;
cDbStatement *select = new cDbStatement(tRecordings);
select->build("select ");
select->bind(cTableRecordings::fiRecPath, cDBS::bndOut);
select->bind(cTableRecordings::fiRecStart, cDBS::bndOut, ", ");
select->build(" from %s where ", tRecordings->TableName());
select->bind(cTableRecordings::fiUuid, cDBS::bndIn | cDBS::bndSet);
status += select->prepare();
if (status != success) {
delete select;
return 0;
}
tRecordings->clear();
tRecordings->setValue(cTableRecordings::fiUuid, config.uuid.c_str());
int numRecsDeleted = 0;
for (int res = select->find(); res; res = select->fetch()) {
int recStart = tRecordings->getIntValue(cTableRecordings::fiRecStart);
string recPath = tRecordings->getStrValue(cTableRecordings::fiRecPath);
if (!Recordings.GetByName(recPath.c_str())) {
stringstream delWhere;
delWhere << "uuid = '" << config.uuid << "' and rec_path = '" << recPath << "' and rec_start = " << recStart;
tRecordings->deleteWhere(delWhere.str().c_str());
numRecsDeleted++;
}
}
select->freeResult();
delete select;
return numRecsDeleted;
}
//***************************************************************************
// Action
//***************************************************************************
void cUpdate::Action() {
tell(0, "Update thread started (pid=%d)", getpid());
mutex.Lock();
loopActive = yes;
int sleep = 10;
Updated README
2014-04-13 07:52:48 +02:00
int scanFreq = 60 * 2;
initial commit
2014-04-12 17:10:43 +02:00
int scanNewRecFreq = 60 * 5;
int scanNewRecDBFreq = 60 * 5;
Updated README
2014-04-13 07:52:48 +02:00
int cleanUpFreq = 60 * 10;
initial commit
2014-04-12 17:10:43 +02:00
forceUpdate = true;
forceRecordingUpdate = true;
time_t lastScan = time(0);
time_t lastScanNewRec = time(0);
time_t lastScanNewRecDB = time(0);
time_t lastCleanup = time(0);
bool init = true;
while (loopActive && Running()) {
int reconnectTimeout; //set by checkConnection
if (CheckConnection(reconnectTimeout) != success) {
waitCondition.TimedWait(mutex, reconnectTimeout*1000);
continue;
}
//Update Events
if (!config.headless && (forceUpdate || (time(0) - lastScan > scanFreq))) {
if (!init && CheckEpgdBusy())
continue;
int numNewEvents = ReadScrapedEvents();
if (numNewEvents > 0) {
tell(0, "Loaded %d new scraped Events from Database", numNewEvents);
} else {
lastScan = time(0);
forceUpdate = false;
init = false;
continue;
}
tell(0, "Loading new Series and Episodes from Database...");
time_t now = time(0);
int numNewSeries = ReadSeries(false);
int dur = time(0) - now;
tell(0, "Loaded %d new Series and Episodes in %ds from Database", numNewSeries, dur);
//scrapManager->DumpSeries(5);
tell(0, "Loading new Movies from Database...");
now = time(0);
int numNewMovies = ReadMovies(false);
dur = time(0) - now;
tell(0, "Loaded %d new Movies in %ds from Database", numNewMovies, dur);
//scrapManager->DumpMovies(5);
lastScan = time(0);
forceUpdate = false;
}
//Update Recordings from Database
if (forceRecordingUpdate || (time(0) - lastScanNewRecDB > scanNewRecDBFreq)) {
if (!init && CheckEpgdBusy())
continue;
int numNewRecs = ReadRecordings();
if (numNewRecs > 0) {
int numSeries = ReadSeries(true);
int numMovies = ReadMovies(true);
tell(0, "Loaded %d new Recordings from Database, %d series, %d movies", numNewRecs, numSeries, numMovies);
}
forceRecordingUpdate = false;
}
//Scan new recordings
if (init || forceVideoDirUpdate || (time(0) - lastScanNewRec > scanNewRecFreq)) {
if (CheckEpgdBusy()) {
waitCondition.TimedWait(mutex, 1000);
continue;
}
static int recState = 0;
if (Recordings.StateChanged(recState)) {
tell(0, "Searching for new recordings because of Recordings State Change...");
int newRecs = ScanVideoDir();
tell(0, "found %d new recordings", newRecs);
}
lastScanNewRec = time(0);
forceVideoDirUpdate = false;
}
init = false;
//Scan Video dir for scrapinfo files
if (forceScrapInfoUpdate) {
if (CheckEpgdBusy()) {
tell(0, "epgd busy, try again in 1s...");
waitCondition.TimedWait(mutex, 1000);
continue;
}
tell(0, "Checking for new or updated scrapinfo files in recordings...");
int numUpdated = ScanVideoDirScrapInfo();
tell(0, "found %d new or updated scrapinfo files", numUpdated);
forceScrapInfoUpdate = false;
}
//Cleanup
if (time(0) - lastCleanup > cleanUpFreq) {
if (CheckEpgdBusy()) {
waitCondition.TimedWait(mutex, 1000);
continue;
}
int seriesDeleted = CleanupSeries();
int moviesDeleted = CleanupMovies();
if (seriesDeleted > 0 || moviesDeleted > 0) {
tell(0, "Deleted %d outdated series image folders", seriesDeleted);
tell(0, "Deleted %d outdated movie image folders", moviesDeleted);
}
lastCleanup = time(0);
}
//Cleanup Recording DB
if (forceCleanupRecordingDb) {
if (CheckEpgdBusy()) {
waitCondition.TimedWait(mutex, 1000);
continue;
}
tell(0, "Cleaning up recordings in database...");
int recsDeleted = CleanupRecordings();
tell(0, "Deleted %d not anymore existing recordings in database", recsDeleted);
forceCleanupRecordingDb = false;
}
waitCondition.TimedWait(mutex, sleep*1000);
}
loopActive = no;
tell(0, "Update thread ended (pid=%d)", getpid());
}
//***************************************************************************
// External trigggering of Actions
//***************************************************************************
void cUpdate::ForceUpdate(void) {
tell(0, "full update from database forced");
forceUpdate = true;
}
void cUpdate::ForceRecordingUpdate(void) {
tell(0, "scanning of recordings in database triggered");
forceRecordingUpdate = true;
}
void cUpdate::ForceVideoDirUpdate(void) {
tell(0, "scanning for new recordings in video directory triggered");
forceVideoDirUpdate = true;
}
void cUpdate::ForceScrapInfoUpdate(void) {
tell(0, "scanning of recording scrapinfo files triggered");
forceScrapInfoUpdate = true;
}
void cUpdate::TriggerCleanRecordingsDB(void) {
tell(0, "cleanup of recording DB triggered");
forceCleanupRecordingDb = true;
}
Reference in New Issue Copy Permalink