vdr-plugin-scraper2vdr/update.c

#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(1);
    while (Active())
        cCondWait::SleepMs(10);
}

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);
    }
    select->build(" order by %s", tEvents->getField(cTableEvents::fiInsSp)->name);
    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() && Running()) {
        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) && Running()) {
        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);
    int res = tEpisodes->find();
    if (res) {
        scrapManager->AddSeriesEpisode(series, tEpisodes);
        LoadEpisodeImage(series, episodeId, path);
        int season = tEpisodes->getIntValue(cTableSeriesEpisode::fiSeasonNumber);
        if (season > 0)
            LoadSeasonPoster(series, season, path);
    }
    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 (!imgExists)
        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 (!imgExists)
        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 (!imgExists)
        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) && Running()) {
        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 = getRecPath(rec);
        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 = "";
            string title = rec->Name();
            //remove directory
            size_t posDelim = title.find_last_of('~');
            if (posDelim != string::npos) {
                title = title.substr(posDelim+1);
            }
            string subTitle = "";
            const cRecordingInfo *recInfo = rec->Info();
            if (recInfo) {
                const cEvent *recEvent = recInfo->GetEvent();
                if (recEvent) {
                    eventId = recEvent->EventID();
                    channelId = *(recInfo->ChannelID().ToString());
                    if (recInfo->Title())
                        title = recInfo->Title();
                    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 = getRecPath(rec);
        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;
    int scanFreq = 60 * 2;
    int scanNewRecFreq = 60 * 5;
    int scanNewRecDBFreq = 60 * 5;
    int cleanUpFreq = 60 * 10;
    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 Recordings from Database
        if (forceRecordingUpdate || (time(0) - lastScanNewRecDB > scanNewRecDBFreq) && Running()) {
            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;
        }

        //Update Events
        if (!config.headless && (forceUpdate || (time(0) - lastScan > scanFreq)) && Running()) {
            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 Movies from Database...");
            time_t now = time(0);
            int numNewMovies = ReadMovies(false);
            int dur = time(0) - now;
            tell(0, "Loaded %d new Movies in %ds from Database", numNewMovies, dur);

            tell(0, "Loading new Series and Episodes from Database...");
            now = time(0);
            int numNewSeries = ReadSeries(false);
            dur = time(0) - now;
            tell(0, "Loaded %d new Series and Episodes in %ds from Database", numNewSeries, dur);

            lastScan = time(0);
            forceUpdate = false;
        }
        
        //Scan new recordings
        if ((init || forceVideoDirUpdate || (time(0) - lastScanNewRec > scanNewRecFreq)) && Running()) {
            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) && Running()){
           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;
}