Ticket #2282: 2282.patch

File 2282.patch, 23.9 KB (added by danielk, 14 years ago)
  • programs/mythfrontend/playbackbox.cpp

     
    14051405
    14061406void PlaybackBox::listChanged(void)
    14071407{
     1408    VERBOSE(VB_IMPORTANT, "PlaybackBox::listChanged() -- begin");
    14081409    if (playingSomething)
    14091410        return;
    14101411
     
    14131414    update(drawTotalBounds);
    14141415    if (type == Delete)
    14151416        UpdateProgressBar();
     1417    VERBOSE(VB_IMPORTANT, "PlaybackBox::listChanged() -- end");
    14161418}
    14171419
    14181420bool PlaybackBox::FillList()
    14191421{
     1422    VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- begin");
    14201423    ProgramInfo *p;
    14211424
    14221425    // Save some information so we can find our place again.
     
    15371540        titleIndex = 0;
    15381541        playList.clear();
    15391542
     1543        VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- end 1");
    15401544        return 0;
    15411545    }
    15421546
     
    16561660        }
    16571661    }
    16581662
     1663    VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- end 2");
    16591664    return (infoList != NULL);
    16601665}
    16611666
     
    21952200
    21962201void PlaybackBox::showDeletePopup(ProgramInfo *program, deletePopupType types)
    21972202{
     2203    VERBOSE(VB_IMPORTANT, "PlaybackBox::showDeletePopup() -- begin");
     2204
    21982205    freeSpaceNeedsUpdate = true;
    21992206
    22002207    popup = new MythPopupBox(gContext->GetMainWindow(), drawPopupSolid,
     
    22972304    popup->ShowPopup(this, SLOT(doCancel()));
    22982305
    22992306    expectingPopup = true;
     2307
     2308    VERBOSE(VB_IMPORTANT, "PlaybackBox::showDeletePopup() -- end");
    23002309}
    23012310
    23022311void PlaybackBox::showAvailablePopup(ProgramInfo *rec)
     
    31653174
    31663175void PlaybackBox::doDelete(void)
    31673176{
     3177    VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- begin");
     3178
    31683179    if (!expectingPopup)
    31693180    {
    31703181        previewSuspend = false;
     3182        VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 1");
    31713183        return;
    31723184    }
    31733185
     
    31783190    {
    31793191        showAvailablePopup(delitem);
    31803192        previewSuspend = false;
     3193        VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 2");
    31813194        return;
    31823195    }
    31833196
     
    31963209    }
    31973210    else
    31983211        showDeletePopup(delitem, ForceDeleteRecording);
     3212
     3213    VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 3");
    31993214}
    32003215
    32013216void PlaybackBox::doForceDelete(void)
  • programs/mythbackend/mainserver.cpp

     
    968968
    969969void MainServer::HandleQueryRecordings(QString type, PlaybackSock *pbs)
    970970{
     971    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- begin");
     972
    971973    MythSocket *pbssock = pbs->getSocket();
     974    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- A");
    972975    bool islocal = pbs->isLocal();
     976    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- B");
    973977    QString playbackhost = pbs->getHostname();
     978    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- C");
    974979
    975980    QString fs_db_name = "";
    976981
     
    979984    RecIter ri;
    980985    RecList schedList;
    981986    if (m_sched)
     987    {
     988        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- D");
    982989        m_sched->getAllPending(&schedList);
     990        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- E");
     991    }
    983992
    984993    QString ip = gContext->GetSetting("BackendServerIP");
    985994    QString port = gContext->GetSetting("BackendServerPort");
     
    989998    QString inUseForWhat;
    990999    QDateTime oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
    9911000
     1001    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- F");
    9921002    MSqlQuery query(MSqlQuery::InitCon());
     1003    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- G");
    9931004
    9941005    query.prepare("SELECT DISTINCT chanid, starttime, recusage "
    9951006                  " FROM inuseprograms WHERE lastupdatetime >= :ONEHOURAGO ;");
    9961007    query.bindValue(":ONEHOURAGO", oneHourAgo);
    9971008
     1009    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 0");
     1010
    9981011    if (query.exec() && query.isActive() && query.size() > 0)
    9991012        while (query.next())
    10001013        {
     
    10131026                inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSERECORDING;
    10141027        }
    10151028
     1029    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 1");
    10161030
    10171031    QString thequery =
    10181032        "SELECT recorded.chanid,recorded.starttime,recorded.endtime,"
     
    10561070
    10571071    query.prepare(thequery);
    10581072
     1073    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.0");
     1074
    10591075    if (!query.exec() || !query.isActive())
    10601076    {
    10611077        MythContext::DBError("ProgramList::FromRecorded", query);
     
    10651081    {
    10661082        outputlist << QString::number(query.size());
    10671083
     1084        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.1");
     1085
    10681086        while (query.next())
    10691087        {
    10701088            ProgramInfo *proginfo = new ProgramInfo;
     
    12531271
    12541272            delete proginfo;
    12551273        }
     1274        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.2");
    12561275    }
    12571276
     1277    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 3");
     1278
    12581279    for (ri = schedList.begin(); ri != schedList.end(); ri++)
    12591280        delete (*ri);
    12601281
     1282    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- sending");
    12611283    SendResponse(pbssock, outputlist);
     1284    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- end");
    12621285}
    12631286
    12641287void MainServer::HandleFillProgramInfo(QStringList &slist, PlaybackSock *pbs)
  • programs/mythbackend/scheduler.cpp

     
    7575    }
    7676}
    7777
    78 Scheduler::~Scheduler()
     78static void delete_reclist(RecList &reclist)
    7979{
    8080    while (reclist.size() > 0)
    8181    {
     
    8585    }
    8686}
    8787
     88static void copy_reclist(RecList &copy, const RecList &orig)
     89{
     90    delete_reclist(copy);
     91
     92    RecList::const_iterator it = orig.begin();
     93    for (; it != orig.end(); it++)
     94        copy.push_back(new ProgramInfo(*(*it)));
     95}
     96
     97Scheduler::~Scheduler()
     98{
     99    delete_reclist(reclist);
     100
     101    if (reclist_lock)
     102    {
     103        delete reclist_lock;
     104        reclist_lock = NULL;
     105    }
     106
     107    if (schedlist_lock)
     108    {
     109        delete schedlist_lock;
     110        schedlist_lock = NULL;
     111    }
     112}
     113
    88114void Scheduler::SetMainServer(MainServer *ms)
    89115{
    90116    m_mainServer = ms;
     
    262288
    263289bool Scheduler::FillRecordList(void)
    264290{
    265     QMutexLocker lockit(reclist_lock);
    266 
    267291    schedMoveHigher = (bool)gContext->GetNumSetting("SchedMoveHigher");
    268292    schedTime = QDateTime::currentDateTime();
    269293
    270     VERBOSE(VB_SCHEDULE, "PruneOldRecords...");
    271     PruneOldRecords();
    272     VERBOSE(VB_SCHEDULE, "AddNewRecords...");
    273     AddNewRecords();
    274     VERBOSE(VB_SCHEDULE, "AddNotListed...");
    275     AddNotListed();
     294    RecList newlist;
    276295
    277     VERBOSE(VB_SCHEDULE, "Sort by time...");
    278     reclist.sort(comp_overlap);
    279     VERBOSE(VB_SCHEDULE, "PruneOverlaps...");
    280     PruneOverlaps();
     296    VERBOSE(VB_IMPORTANT, "PruneOldRecords...");
     297    PruneOldRecords(newlist);
     298    VERBOSE(VB_IMPORTANT, "AddNewRecords...");
     299    AddNewRecords(dbConn, recordTable, specsched, threadrunning,
     300                  *m_tvList, newlist);
     301    VERBOSE(VB_IMPORTANT, "AddNotListed...");
     302    AddNotListed(dbConn, recordTable, newlist);
    281303
    282     VERBOSE(VB_SCHEDULE, "Sort by priority...");
    283     reclist.sort(comp_priority);
    284     VERBOSE(VB_SCHEDULE, "BuildListMaps...");
    285     BuildListMaps();
    286     VERBOSE(VB_SCHEDULE, "SchedNewRecords...");
    287     SchedNewRecords();
    288     VERBOSE(VB_SCHEDULE, "ClearListMaps...");
    289     ClearListMaps();
     304    VERBOSE(VB_IMPORTANT, "Sort by time...");
     305    newlist.sort(comp_overlap);
     306    VERBOSE(VB_IMPORTANT, "PruneOverlaps...");
     307    PruneOverlaps(newlist);
    290308
    291     VERBOSE(VB_SCHEDULE, "Sort by time...");
    292     reclist.sort(comp_redundant);
    293     VERBOSE(VB_SCHEDULE, "PruneRedundants...");
    294     PruneRedundants();
     309    VERBOSE(VB_IMPORTANT, "Sort by priority...");
     310    newlist.sort(comp_priority);
     311    VERBOSE(VB_IMPORTANT, "BuildListMaps...");
    295312
    296     VERBOSE(VB_SCHEDULE, "Sort by time...");
    297     reclist.sort(comp_recstart);
     313    RecList                retrylist;
     314    QMap<int, RecList>     cardlistmap;
     315    QMap<int, RecList>     recordidlistmap;
     316    QMap<QString, RecList> titlelistmap;
    298317
     318    BuildListMaps(newlist, cardlistmap, recordidlistmap, titlelistmap);
     319
     320    VERBOSE(VB_IMPORTANT, "SchedNewRecords...");
     321    SchedNewRecords(schedMoveHigher, newlist, retrylist,
     322                    cardlistmap, recordidlistmap, titlelistmap);
     323    VERBOSE(VB_IMPORTANT, "ClearListMaps...");
     324    ClearListMaps(cardlistmap, recordidlistmap, titlelistmap);
     325
     326    VERBOSE(VB_IMPORTANT, "Sort by time...");
     327    newlist.sort(comp_redundant);
     328    VERBOSE(VB_IMPORTANT, "PruneRedundants...");
     329    bool newhasconflicts = PruneRedundants(newlist);
     330
     331    VERBOSE(VB_IMPORTANT, "Sort by time...");
     332    newlist.sort(comp_recstart);
     333
     334    {
     335        VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- locking");
     336        QMutexLocker lockit(reclist_lock);
     337        VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- locked");
     338        copy_reclist(reclist, newlist);
     339        hasconflicts = newhasconflicts;
     340    }
     341    VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- unlocked");
     342    delete_reclist(newlist);
     343
    299344    return hasconflicts;
    300345}
    301346
     
    475520    }
    476521}
    477522
    478 bool Scheduler::ChangeRecordingEnd(ProgramInfo *oldp, ProgramInfo *newp)
     523bool Scheduler::ChangeRecordingEnd(const bool specsched,
     524                                   QMap<int, EncoderLink*> &tvList,
     525                                   ProgramInfo *oldp,
     526                                   ProgramInfo *newp)
    479527{
    480528    RecordingType oldrectype = oldp->rectype;
    481529    int oldrecordid = oldp->recordid;
     
    496544        else
    497545            return true;
    498546    }
    499     EncoderLink *tv = (*m_tvList)[oldp->cardid];
     547    EncoderLink *tv = tvList[oldp->cardid];
    500548    RecStatusType rs = tv->StartRecording(oldp);
    501549    if (rs != rsRecording)
    502550    {
     
    586634    }
    587635}
    588636
    589 void Scheduler::PruneOldRecords(void)
     637void Scheduler::PruneOldRecords(RecList &reclist)
    590638{
    591639    RecIter dreciter = reclist.begin();
    592640    while (dreciter != reclist.end())
     
    606654    }
    607655}
    608656
    609 void Scheduler::PruneOverlaps(void)
     657void Scheduler::PruneOverlaps(RecList &reclist)
    610658{
    611659    ProgramInfo *lastp = NULL;
    612660
     
    647695    }
    648696}
    649697
    650 void Scheduler::BuildListMaps(void)
     698void Scheduler::BuildListMaps(RecList                &reclist,
     699                              QMap<int, RecList>     &cardlistmap,
     700                              QMap<int, RecList>     &recordidlistmap,
     701                              QMap<QString, RecList> &titlelistmap)
    651702{
    652703    RecIter i = reclist.begin();
    653704    for ( ; i != reclist.end(); i++)
     
    664715    }
    665716}
    666717
    667 void Scheduler::ClearListMaps(void)
     718void Scheduler::ClearListMaps(QMap<int, RecList>     &cardlistmap,
     719                              QMap<int, RecList>     &recordidlistmap,
     720                              QMap<QString, RecList> &titlelistmap)
    668721{
    669722    cardlistmap.clear();
    670723    titlelistmap.clear();
     
    694747    return false;
    695748}
    696749
    697 void Scheduler::MarkOtherShowings(ProgramInfo *p)
     750void Scheduler::MarkOtherShowings(ProgramInfo *p,
     751                                  QMap<int, RecList>     &recordidlistmap,
     752                                  QMap<QString, RecList> &titlelistmap)
    698753{
    699754    RecList *showinglist = &titlelistmap[p->title];
    700755
     
    742797    }
    743798}
    744799
    745 void Scheduler::BackupRecStatus(void)
     800void Scheduler::BackupRecStatus(RecList &reclist)
    746801{
    747802    RecIter i = reclist.begin();
    748803    for ( ; i != reclist.end(); i++)
     
    752807    }
    753808}
    754809
    755 void Scheduler::RestoreRecStatus(void)
     810void Scheduler::RestoreRecStatus(RecList &reclist)
    756811{
    757812    RecIter i = reclist.begin();
    758813    for ( ; i != reclist.end(); i++)
     
    762817    }
    763818}
    764819
    765 bool Scheduler::TryAnotherShowing(ProgramInfo *p)
     820bool Scheduler::TryAnotherShowing(QMap<int, RecList>     &cardlistmap,
     821                                  QMap<QString, RecList> &titlelistmap,
     822                                  QMap<int, RecList>     &recordidlistmap,
     823                                  ProgramInfo *p)
    766824{
    767825    PrintRec(p, "     >");
    768826
     
    811869        }
    812870
    813871        q->recstatus = rsWillRecord;
    814         MarkOtherShowings(q);
     872        MarkOtherShowings(q, recordidlistmap, titlelistmap);
    815873        PrintRec(p, "     -");
    816874        PrintRec(q, "     +");
    817875        return true;
     
    821879    return false;
    822880}
    823881
    824 void Scheduler::SchedNewRecords(void)
     882void Scheduler::SchedNewRecords(const bool              schedMoveHigher,
     883                                RecList                &reclist,
     884                                RecList                &retrylist,
     885                                QMap<int, RecList>     &cardlistmap,
     886                                QMap<int, RecList>     &recordidlistmap,
     887                                QMap<QString, RecList> &titlelistmap)
    825888{
    826889    VERBOSE(VB_SCHEDULE, "Scheduling:");
    827890
     
    830893    {
    831894        ProgramInfo *p = *i;
    832895        if (p->recstatus == rsRecording)
    833             MarkOtherShowings(p);
     896            MarkOtherShowings(p, recordidlistmap, titlelistmap);
    834897        else if (p->recstatus == rsUnknown)
    835898        {
    836899            RecList &cardlist = cardlistmap[p->cardid];
     
    838901            if (!FindNextConflict(cardlist, p, k))
    839902            {
    840903                p->recstatus = rsWillRecord;
    841                 MarkOtherShowings(p);
     904                MarkOtherShowings(p, recordidlistmap, titlelistmap);
    842905                PrintRec(p, "  +");
    843906            }
    844907            else
     
    853916        i++;
    854917        if (i == reclist.end() || lastpri != (*i)->recpriority)
    855918        {
    856             MoveHigherRecords();
     919            MoveHigherRecords(schedMoveHigher, reclist, retrylist,
     920                              cardlistmap, recordidlistmap, titlelistmap);
    857921            retrylist.clear();
    858922        }
    859923    }
    860924}
    861925
    862 void Scheduler::MoveHigherRecords(void)
     926void Scheduler::MoveHigherRecords(const bool              schedMoveHigher,
     927                                  RecList                &reclist,
     928                                  RecList                &retrylist,
     929                                  QMap<int, RecList>     &cardlistmap,
     930                                  QMap<int, RecList>     &recordidlistmap,
     931                                  QMap<QString, RecList> &titlelistmap)
    863932{
    864933    RecIter i = retrylist.begin();
    865934    for ( ; i != retrylist.end(); i++)
     
    870939
    871940        PrintRec(p, "  ?");
    872941
    873         if (TryAnotherShowing(p))
     942        if (TryAnotherShowing(cardlistmap, titlelistmap, recordidlistmap, p))
    874943            continue;
    875944
    876         BackupRecStatus();
     945        BackupRecStatus(reclist);
    877946        p->recstatus = rsWillRecord;
    878         MarkOtherShowings(p);
     947        MarkOtherShowings(p, recordidlistmap, titlelistmap);
    879948
    880949        RecList &cardlist = cardlistmap[p->cardid];
    881950        RecIter k = cardlist.begin();
    882951        for ( ; FindNextConflict(cardlist, p, k); k++)
    883952        {
    884953            if ((p->recpriority < (*k)->recpriority && !schedMoveHigher) ||
    885                 !TryAnotherShowing(*k))
     954                !TryAnotherShowing(cardlistmap, titlelistmap,
     955                                   recordidlistmap, *k))
    886956            {
    887                 RestoreRecStatus();
     957                RestoreRecStatus(reclist);
    888958                break;
    889959            }
    890960        }
     
    894964    }
    895965}
    896966
    897 void Scheduler::PruneRedundants(void)
     967bool Scheduler::PruneRedundants(RecList &reclist)
    898968{
    899969    ProgramInfo *lastp = NULL;
    900     hasconflicts = false;
     970    bool hasconflicts = false;
    901971
    902972    RecIter i = reclist.begin();
    903973    while (i != reclist.end())
     
    9471017            i = reclist.erase(i);
    9481018        }
    9491019    }
     1020
     1021    return hasconflicts;
    9501022}
    9511023
    9521024void Scheduler::getConflicting(ProgramInfo *pginfo, QStringList &strlist)
     
    9841056{
    9851057    QMutexLocker lockit(reclist_lock);
    9861058
    987     while (retList->size() > 0)
    988     {
    989         ProgramInfo *pginfo = retList->back();
    990         delete pginfo;
    991         retList->pop_back();
    992     }
    993 
    994     RecIter i = reclist.begin();
    995     for (; i != reclist.end(); i++)
    996     {
    997         ProgramInfo *p = *i;
    998         retList->push_back(new ProgramInfo(*p));
    999     }
     1059    copy_reclist(*retList, reclist);
    10001060    retList->sort(comp_timechannel);
    10011061}
    10021062
    10031063void Scheduler::getAllPending(QStringList &strList)
    10041064{
    1005     QMutexLocker lockit(reclist_lock);
     1065    RecList retList;
     1066    getAllPending(&retList);
    10061067
    10071068    strList << QString::number(hasconflicts);
    1008     strList << QString::number(reclist.size());
     1069    strList << QString::number(retList.size());
    10091070
    1010     RecList *retList = new RecList;
     1071    for (RecIter it = retList.begin(); it != retList.end(); ++it)
     1072        (*it)->ToStringList(strList);
    10111073
    1012     RecIter i = reclist.begin();
    1013     for (; i != reclist.end(); i++)
    1014     {
    1015         ProgramInfo *p = *i;
    1016         retList->push_back(new ProgramInfo(*p));
    1017     }
    1018     retList->sort(comp_timechannel);
    1019 
    1020     for (i = retList->begin(); i != retList->end(); i++)
    1021     {
    1022         ProgramInfo *p = *i;
    1023         p->ToStringList(strList);
    1024         delete p;
    1025     }
    1026 
    1027     delete retList;
     1074    delete_reclist(retList);
    10281075}
    10291076
    10301077RecList *Scheduler::getAllScheduled(void)
    10311078{
    1032     while (schedlist.size() > 0)
    1033     {
    1034         ProgramInfo *pginfo = schedlist.back();
    1035         delete pginfo;
    1036         schedlist.pop_back();
    1037     }
     1079    delete_reclist(schedlist);
    10381080
    10391081    findAllScheduledPrograms(schedlist);
    10401082
     
    19301972    VERBOSE(VB_SCHEDULE, " +-- Done.");
    19311973}
    19321974
    1933 void Scheduler::AddNewRecords(void)
     1975void Scheduler::AddNewRecords(MSqlQueryInfo           &dbConn,
     1976                              const QString           &recordTable,
     1977                              const bool               specsched,
     1978                              const bool               threadrunning,
     1979                              QMap<int, EncoderLink*> &tvList,
     1980                              RecList                 &reclist)
    19341981{
    19351982    struct timeval dbstart, dbend;
    19361983
     
    19441991    int ccpriority      = gContext->GetNumSetting("CCRecPriority", 0);
    19451992
    19461993    QMap<int, bool> cardMap;
    1947     QMap<int, EncoderLink *>::Iterator enciter = m_tvList->begin();
    1948     for (; enciter != m_tvList->end(); ++enciter)
     1994    QMap<int, EncoderLink *>::Iterator enciter = tvList.begin();
     1995    for (; enciter != tvList.end(); ++enciter)
    19491996    {
    19501997        EncoderLink *enc = enciter.data();
    19511998        if (enc->IsConnected())
     
    22552302                    r->recendts != p->recendts &&
    22562303                    (r->recordid == p->recordid ||
    22572304                     p->rectype == kOverrideRecord))
    2258                     ChangeRecordingEnd(r, p);
     2305                {
     2306                    ChangeRecordingEnd(specsched, tvList, r, p);
     2307                }
    22592308                delete p;
    22602309                p = NULL;
    22612310                break;
     
    23122361        reclist.push_back(*tmp);
    23132362}
    23142363
    2315 void Scheduler::AddNotListed(void) {
    2316 
     2364void Scheduler::AddNotListed(MSqlQueryInfo &dbConn,
     2365                             const QString &recordTable,
     2366                             RecList       &reclist)
     2367{
    23172368    struct timeval dbstart, dbend;
    23182369    RecList tmpList;
    23192370
  • programs/mythbackend/scheduler.h

     
    4949    RecList *getConflicting(ProgramInfo *pginfo);
    5050
    5151    void PrintList(bool onlyFutureRecordings = false);
    52     void PrintRec(ProgramInfo *p, const char *prefix = NULL);
     52    static void PrintRec(ProgramInfo *p, const char *prefix = NULL);
    5353
    5454    bool HasConflicts(void) { return hasconflicts; }
    5555
     
    7070    bool FillRecordList(void);
    7171    void UpdateMatches(int recordid);
    7272    void UpdateManuals(int recordid);
    73     void PruneOldRecords(void);
    74     void AddNewRecords(void);
    75     void AddNotListed(void);
     73    static void PruneOldRecords(RecList&);
     74    static void AddNewRecords(MSqlQueryInfo           &dbConn,
     75                              const QString           &recordTable,
     76                              bool                     specsched,
     77                              bool                     threadrunning,
     78                              QMap<int, EncoderLink*> &tvList,
     79                              RecList                 &reclist);
     80    static void AddNotListed(MSqlQueryInfo &dbConn,
     81                             const QString &recordTable, RecList&);
    7682    void BuildNewRecordsQueries(int recordid, QStringList &from, QStringList &where,
    7783                                MSqlBindings &bindings);
    78     void PruneOverlaps(void);
    79     void BuildListMaps(void);
    80     void ClearListMaps(void);
    81     bool FindNextConflict(RecList &cardlist, ProgramInfo *p, RecIter &iter);
    82     void MarkOtherShowings(ProgramInfo *p);
    83     void MarkShowingsList(RecList &showinglist, ProgramInfo *p);
    84     void BackupRecStatus(void);
    85     void RestoreRecStatus(void);
    86     bool TryAnotherShowing(ProgramInfo *p);
    87     void SchedNewRecords(void);
    88     void MoveHigherRecords(void);
    89     void PruneRedundants(void);
     84    static void PruneOverlaps(RecList&);
     85    static void BuildListMaps(RecList                &reclist,
     86                              QMap<int, RecList>     &cardlistmap,
     87                              QMap<int, RecList>     &recordidlistmap,
     88                              QMap<QString, RecList> &titlelistmap);
     89    static void ClearListMaps(QMap<int, RecList>     &cardlistmap,
     90                              QMap<int, RecList>     &recordidlistmap,
     91                              QMap<QString, RecList> &titlelistmap);
     92    static bool FindNextConflict(RecList &cardlist,
     93                                 ProgramInfo *p, RecIter &iter);
     94    static void MarkOtherShowings(ProgramInfo *p,
     95                                  QMap<int, RecList>     &recordidlistmap,
     96                                  QMap<QString, RecList> &titlelistmap);
     97    static void MarkShowingsList(RecList &showinglist, ProgramInfo *p);
     98    static void BackupRecStatus(RecList &reclist);
     99    static void RestoreRecStatus(RecList &reclist);
     100    static bool TryAnotherShowing(QMap<int, RecList>     &cardlistmap,
     101                                  QMap<QString, RecList> &titlelistmap,
     102                                  QMap<int, RecList>     &recordidlistmap,
     103                                  ProgramInfo *p);
     104    static void SchedNewRecords(const bool              schedMoveHigher,
     105                                RecList                &reclist,
     106                                RecList                &retrylist,
     107                                QMap<int, RecList>     &cardlistmap,
     108                                QMap<int, RecList>     &recordidlistmap,
     109                                QMap<QString, RecList> &titlelistmap);
     110    static void MoveHigherRecords(const bool              schedMoveHigher,
     111                                  RecList                &reclist,
     112                                  RecList                &retrylist,
     113                                  QMap<int, RecList>     &cardlistmap,
     114                                  QMap<int, RecList>     &recordidlistmap,
     115                                  QMap<QString, RecList> &titlelistmap);
     116    static bool PruneRedundants(RecList&);
     117    static bool ChangeRecordingEnd(bool specsched,
     118                                   QMap<int, EncoderLink*> &tvList,
     119                                   ProgramInfo *oldp, ProgramInfo *newp);
    90120
    91     bool ChangeRecordingEnd(ProgramInfo *oldp, ProgramInfo *newp);
    92 
    93121    void findAllScheduledPrograms(list<ProgramInfo *> &proglist);
    94122    bool CheckShutdownServer(int prerollseconds, QDateTime &idleSince,
    95123                             bool &blockShutdown);
     
    101129    QMutex recordmatchLock;
    102130    QWaitCondition reschedWait;
    103131    RecList reclist;
    104     RecList retrylist;
    105132    RecList schedlist;
    106     QMap<int, RecList> cardlistmap;
    107     QMap<int, RecList> recordidlistmap;
    108     QMap<QString, RecList> titlelistmap;
    109133
    110134    QMutex *reclist_lock;
    111135    QMutex *schedlist_lock;