Ticket #2282: 2282-v2.patch

File 2282-v2.patch, 25.2 KB (added by danielk, 14 years ago)

Updated version of patch

  • programs/mythfrontend/playbackbox.cpp

     
    14421442
    14431443void PlaybackBox::listChanged(void)
    14441444{
     1445    VERBOSE(VB_IMPORTANT, "PlaybackBox::listChanged() -- begin");
    14451446    if (playingSomething)
    14461447        return;
    14471448
     
    14501451    update(drawTotalBounds);
    14511452    if (type == Delete)
    14521453        UpdateProgressBar();
     1454    VERBOSE(VB_IMPORTANT, "PlaybackBox::listChanged() -- end");
    14531455}
    14541456
    14551457bool PlaybackBox::FillList(bool useCachedData)
    14561458{
     1459    VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- begin");
    14571460    ProgramInfo *p;
    14581461
    14591462    // Save some information so we can find our place again.
     
    16071610        titleIndex = 0;
    16081611        playList.clear();
    16091612
     1613        VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- end 1");
    16101614        return 0;
    16111615    }
    16121616
     
    18881892        }
    18891893    }
    18901894
     1895    VERBOSE(VB_IMPORTANT, "PlaybackBox::FillList() -- end 2");
    18911896    return (progCache != NULL);
    18921897}
    18931898
     
    24152420
    24162421void PlaybackBox::showDeletePopup(ProgramInfo *program, deletePopupType types)
    24172422{
     2423    VERBOSE(VB_IMPORTANT, "PlaybackBox::showDeletePopup() -- begin");
     2424
    24182425    freeSpaceNeedsUpdate = true;
    24192426
    24202427    popup = new MythPopupBox(gContext->GetMainWindow(), drawPopupSolid,
     
    25072514    popup->ShowPopup(this, SLOT(doCancel()));
    25082515
    25092516    expectingPopup = true;
     2517
     2518    VERBOSE(VB_IMPORTANT, "PlaybackBox::showDeletePopup() -- end");
    25102519}
    25112520
    25122521void PlaybackBox::showAvailablePopup(ProgramInfo *rec)
     
    33653374
    33663375void PlaybackBox::doDelete(void)
    33673376{
     3377    VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- begin");
     3378
    33683379    if (!expectingPopup)
    33693380    {
    33703381        previewSuspend = false;
     3382        VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 1");
    33713383        return;
    33723384    }
    33733385
     
    33783390    {
    33793391        showAvailablePopup(delitem);
    33803392        previewSuspend = false;
     3393        VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 2");
    33813394        return;
    33823395    }
    33833396
     
    33963409    }
    33973410    else
    33983411        showDeletePopup(delitem, ForceDeleteRecording);
     3412
     3413    VERBOSE(VB_IMPORTANT, "PlaybackBox::doDelete() -- end 3");
    33993414}
    34003415
    34013416void PlaybackBox::doForceDelete(void)
  • programs/mythbackend/mainserver.cpp

     
    10041004
    10051005void MainServer::HandleQueryRecordings(QString type, PlaybackSock *pbs)
    10061006{
     1007    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- begin");
     1008
    10071009    MythSocket *pbssock = pbs->getSocket();
     1010    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- A");
    10081011    bool islocal = pbs->isLocal();
     1012    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- B");
    10091013    QString playbackhost = pbs->getHostname();
     1014    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- C");
    10101015
    10111016    QString fs_db_name = "";
    10121017
     
    10151020    RecIter ri;
    10161021    RecList schedList;
    10171022    if (m_sched)
     1023    {
     1024        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- D");
    10181025        m_sched->getAllPending(&schedList);
     1026        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- E");
     1027    }
    10191028
    10201029    QString ip = gContext->GetSetting("BackendServerIP");
    10211030    QString port = gContext->GetSetting("BackendServerPort");
     
    10251034    QString inUseForWhat;
    10261035    QDateTime oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
    10271036
     1037    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- F");
    10281038    MSqlQuery query(MSqlQuery::InitCon());
     1039    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- G");
    10291040
    10301041    query.prepare("SELECT DISTINCT chanid, starttime, recusage "
    10311042                  " FROM inuseprograms WHERE lastupdatetime >= :ONEHOURAGO ;");
    10321043    query.bindValue(":ONEHOURAGO", oneHourAgo);
    10331044
     1045    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 0");
     1046
    10341047    if (query.exec() && query.isActive() && query.size() > 0)
    10351048        while (query.next())
    10361049        {
     
    10491062                inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSERECORDING;
    10501063        }
    10511064
     1065    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 1");
    10521066
    10531067    QString thequery =
    10541068        "SELECT recorded.chanid,recorded.starttime,recorded.endtime,"
     
    10921106
    10931107    query.prepare(thequery);
    10941108
     1109    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.0");
     1110
    10951111    if (!query.exec() || !query.isActive())
    10961112    {
    10971113        MythContext::DBError("ProgramList::FromRecorded", query);
     
    11011117    {
    11021118        outputlist << QString::number(query.size());
    11031119
     1120        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.1");
     1121
    11041122        while (query.next())
    11051123        {
    11061124            ProgramInfo *proginfo = new ProgramInfo;
     
    12901308
    12911309            delete proginfo;
    12921310        }
     1311        VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 2.2");
    12931312    }
    12941313
     1314    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- 3");
     1315
    12951316    for (ri = schedList.begin(); ri != schedList.end(); ri++)
    12961317        delete (*ri);
    12971318
     1319    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- sending");
    12981320    SendResponse(pbssock, outputlist);
     1321    VERBOSE(VB_IMPORTANT, "MainServer::HandleQueryRecordings() -- end");
    12991322}
    13001323
    13011324void MainServer::HandleFillProgramInfo(QStringList &slist, PlaybackSock *pbs)
  • programs/mythbackend/scheduler.cpp

     
    7676    }
    7777}
    7878
    79 Scheduler::~Scheduler()
     79static void delete_reclist(RecList &reclist)
    8080{
    8181    while (reclist.size() > 0)
    8282    {
     
    8686    }
    8787}
    8888
     89static void copy_reclist(RecList &copy, const RecList &orig)
     90{
     91    delete_reclist(copy);
     92
     93    RecList::const_iterator it = orig.begin();
     94    for (; it != orig.end(); it++)
     95        copy.push_back(new ProgramInfo(*(*it)));
     96}
     97
     98Scheduler::~Scheduler()
     99{
     100    delete_reclist(reclist);
     101
     102    if (reclist_lock)
     103    {
     104        delete reclist_lock;
     105        reclist_lock = NULL;
     106    }
     107
     108    if (schedlist_lock)
     109    {
     110        delete schedlist_lock;
     111        schedlist_lock = NULL;
     112    }
     113}
     114
    89115void Scheduler::SetMainServer(MainServer *ms)
    90116{
    91117    m_mainServer = ms;
     
    263289
    264290bool Scheduler::FillRecordList(void)
    265291{
    266     QMutexLocker lockit(reclist_lock);
    267 
    268292    schedMoveHigher = (bool)gContext->GetNumSetting("SchedMoveHigher");
    269293    schedTime = QDateTime::currentDateTime();
    270294
    271     VERBOSE(VB_SCHEDULE, "PruneOldRecords...");
    272     PruneOldRecords();
    273     VERBOSE(VB_SCHEDULE, "AddNewRecords...");
    274     AddNewRecords();
    275     VERBOSE(VB_SCHEDULE, "AddNotListed...");
    276     AddNotListed();
     295    RecList newlist;
     296 
     297    VERBOSE(VB_IMPORTANT, "PruneOldRecords...");
     298    PruneOldRecords(newlist);
     299    VERBOSE(VB_IMPORTANT, "AddNewRecords...");
     300    AddNewRecords(dbConn, recordTable, specsched, threadrunning,
     301                  *m_tvList, newlist);
     302    VERBOSE(VB_IMPORTANT, "AddNotListed...");
     303    AddNotListed(dbConn, recordTable, newlist);
     304 
     305    VERBOSE(VB_IMPORTANT, "Sort by time...");
     306    newlist.sort(comp_overlap);
     307    VERBOSE(VB_IMPORTANT, "PruneOverlaps...");
     308    PruneOverlaps(newlist);
     309 
     310    VERBOSE(VB_IMPORTANT, "Sort by priority...");
     311    newlist.sort(comp_priority);
     312    VERBOSE(VB_IMPORTANT, "BuildListMaps...");
     313 
     314    RecList                retrylist;
     315    QMap<int, RecList>     cardlistmap;
     316    QMap<int, RecList>     recordidlistmap;
     317    QMap<QString, RecList> titlelistmap;
     318 
     319    BuildListMaps(newlist, cardlistmap, recordidlistmap, titlelistmap);
    277320
    278     VERBOSE(VB_SCHEDULE, "Sort by time...");
    279     reclist.sort(comp_overlap);
    280     VERBOSE(VB_SCHEDULE, "PruneOverlaps...");
    281     PruneOverlaps();
     321    VERBOSE(VB_IMPORTANT, "SchedNewRecords...");
     322    SchedNewRecords(schedMoveHigher, newlist, retrylist,
     323                    cardlistmap, recordidlistmap, titlelistmap);
     324    VERBOSE(VB_IMPORTANT, "ClearListMaps...");
     325    ClearListMaps(cardlistmap, recordidlistmap, titlelistmap);
    282326
    283     VERBOSE(VB_SCHEDULE, "Sort by priority...");
    284     reclist.sort(comp_priority);
    285     VERBOSE(VB_SCHEDULE, "BuildListMaps...");
    286     BuildListMaps();
    287     VERBOSE(VB_SCHEDULE, "SchedNewRecords...");
    288     SchedNewRecords();
    289     VERBOSE(VB_SCHEDULE, "ClearListMaps...");
    290     ClearListMaps();
     327    VERBOSE(VB_IMPORTANT, "Sort by time...");
     328    newlist.sort(comp_redundant);
     329    VERBOSE(VB_IMPORTANT, "PruneRedundants...");
     330    bool will_have_conflicts = PruneRedundants(newlist);
    291331
    292     VERBOSE(VB_SCHEDULE, "Sort by time...");
    293     reclist.sort(comp_redundant);
    294     VERBOSE(VB_SCHEDULE, "PruneRedundants...");
    295     PruneRedundants();
     332    VERBOSE(VB_IMPORTANT, "Sort by time...");
     333    newlist.sort(comp_recstart);
    296334
    297     VERBOSE(VB_SCHEDULE, "Sort by time...");
    298     reclist.sort(comp_recstart);
     335    VERBOSE(VB_IMPORTANT, "UpdateNextRecord...");
     336    UpdateNextRecord(dbConn, newlist);
    299337
    300     VERBOSE(VB_SCHEDULE, "UpdateNextRecord...");
    301     UpdateNextRecord();
     338    {
     339        VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- locking");
     340        QMutexLocker lockit(reclist_lock);
     341        VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- locked");
     342        copy_reclist(reclist, newlist);
     343        hasconflicts = will_have_conflicts;
     344    }
     345    VERBOSE(VB_IMPORTANT, "Scheduler::FillRecordList() -- unlocked");
     346    delete_reclist(newlist);
    302347
    303348    return hasconflicts;
    304349}
     
    479524    }
    480525}
    481526
    482 bool Scheduler::ChangeRecordingEnd(ProgramInfo *oldp, ProgramInfo *newp)
     527bool Scheduler::ChangeRecordingEnd(const bool specsched,
     528                                   QMap<int, EncoderLink*> &tvList,
     529                                   ProgramInfo *oldp,
     530                                   ProgramInfo *newp)
    483531{
    484532    RecordingType oldrectype = oldp->rectype;
    485533    int oldrecordid = oldp->recordid;
     
    500548        else
    501549            return true;
    502550    }
    503     EncoderLink *tv = (*m_tvList)[oldp->cardid];
     551    EncoderLink *tv = tvList[oldp->cardid];
    504552    RecStatusType rs = tv->StartRecording(oldp);
    505553    if (rs != rsRecording)
    506554    {
     
    590638    }
    591639}
    592640
    593 void Scheduler::PruneOldRecords(void)
     641void Scheduler::PruneOldRecords(RecList &reclist)
    594642{
    595643    RecIter dreciter = reclist.begin();
    596644    while (dreciter != reclist.end())
     
    610658    }
    611659}
    612660
    613 void Scheduler::PruneOverlaps(void)
     661void Scheduler::PruneOverlaps(RecList &reclist)
    614662{
    615663    ProgramInfo *lastp = NULL;
    616664
     
    651699    }
    652700}
    653701
    654 void Scheduler::BuildListMaps(void)
     702void Scheduler::BuildListMaps(RecList                &reclist,
     703                              QMap<int, RecList>     &cardlistmap,
     704                              QMap<int, RecList>     &recordidlistmap,
     705                              QMap<QString, RecList> &titlelistmap)
    655706{
    656707    RecIter i = reclist.begin();
    657708    for ( ; i != reclist.end(); i++)
     
    668719    }
    669720}
    670721
    671 void Scheduler::ClearListMaps(void)
     722void Scheduler::ClearListMaps(QMap<int, RecList>     &cardlistmap,
     723                              QMap<int, RecList>     &recordidlistmap,
     724                              QMap<QString, RecList> &titlelistmap)
    672725{
    673726    cardlistmap.clear();
    674727    titlelistmap.clear();
     
    698751    return false;
    699752}
    700753
    701 void Scheduler::MarkOtherShowings(ProgramInfo *p)
     754void Scheduler::MarkOtherShowings(ProgramInfo *p,
     755                                  QMap<int, RecList>     &recordidlistmap,
     756                                  QMap<QString, RecList> &titlelistmap)
    702757{
    703758    RecList *showinglist = &titlelistmap[p->title];
    704759
     
    746801    }
    747802}
    748803
    749 void Scheduler::BackupRecStatus(void)
     804void Scheduler::BackupRecStatus(RecList &reclist)
    750805{
    751806    RecIter i = reclist.begin();
    752807    for ( ; i != reclist.end(); i++)
     
    756811    }
    757812}
    758813
    759 void Scheduler::RestoreRecStatus(void)
     814void Scheduler::RestoreRecStatus(RecList &reclist)
    760815{
    761816    RecIter i = reclist.begin();
    762817    for ( ; i != reclist.end(); i++)
     
    766821    }
    767822}
    768823
    769 bool Scheduler::TryAnotherShowing(ProgramInfo *p)
     824bool Scheduler::TryAnotherShowing(QMap<int, RecList>     &cardlistmap,
     825                                  QMap<QString, RecList> &titlelistmap,
     826                                  QMap<int, RecList>     &recordidlistmap,
     827                                  ProgramInfo *p)
    770828{
    771829    PrintRec(p, "     >");
    772830
     
    815873        }
    816874
    817875        q->recstatus = rsWillRecord;
    818         MarkOtherShowings(q);
     876        MarkOtherShowings(q, recordidlistmap, titlelistmap);
    819877        PrintRec(p, "     -");
    820878        PrintRec(q, "     +");
    821879        return true;
     
    825883    return false;
    826884}
    827885
    828 void Scheduler::SchedNewRecords(void)
     886void Scheduler::SchedNewRecords(const bool              schedMoveHigher,
     887                                RecList                &reclist,
     888                                RecList                &retrylist,
     889                                QMap<int, RecList>     &cardlistmap,
     890                                QMap<int, RecList>     &recordidlistmap,
     891                                QMap<QString, RecList> &titlelistmap)
    829892{
    830893    VERBOSE(VB_SCHEDULE, "Scheduling:");
    831894
     
    834897    {
    835898        ProgramInfo *p = *i;
    836899        if (p->recstatus == rsRecording)
    837             MarkOtherShowings(p);
     900            MarkOtherShowings(p, recordidlistmap, titlelistmap);
    838901        else if (p->recstatus == rsUnknown)
    839902        {
    840903            RecList &cardlist = cardlistmap[p->cardid];
     
    842905            if (!FindNextConflict(cardlist, p, k))
    843906            {
    844907                p->recstatus = rsWillRecord;
    845                 MarkOtherShowings(p);
     908                MarkOtherShowings(p, recordidlistmap, titlelistmap);
    846909                PrintRec(p, "  +");
    847910            }
    848911            else
     
    857920        i++;
    858921        if (i == reclist.end() || lastpri != (*i)->recpriority)
    859922        {
    860             MoveHigherRecords();
     923            MoveHigherRecords(schedMoveHigher, reclist, retrylist,
     924                              cardlistmap, recordidlistmap, titlelistmap);
    861925            retrylist.clear();
    862926        }
    863927    }
    864928}
    865929
    866 void Scheduler::MoveHigherRecords(void)
     930void Scheduler::MoveHigherRecords(const bool              schedMoveHigher,
     931                                  RecList                &reclist,
     932                                  RecList                &retrylist,
     933                                  QMap<int, RecList>     &cardlistmap,
     934                                  QMap<int, RecList>     &recordidlistmap,
     935                                  QMap<QString, RecList> &titlelistmap)
    867936{
    868937    RecIter i = retrylist.begin();
    869938    for ( ; i != retrylist.end(); i++)
     
    874943
    875944        PrintRec(p, "  ?");
    876945
    877         if (TryAnotherShowing(p))
     946        if (TryAnotherShowing(cardlistmap, titlelistmap, recordidlistmap, p))
    878947            continue;
    879948
    880         BackupRecStatus();
     949        BackupRecStatus(reclist);
    881950        p->recstatus = rsWillRecord;
    882         MarkOtherShowings(p);
     951        MarkOtherShowings(p, recordidlistmap, titlelistmap);
    883952
    884953        RecList &cardlist = cardlistmap[p->cardid];
    885954        RecIter k = cardlist.begin();
    886955        for ( ; FindNextConflict(cardlist, p, k); k++)
    887956        {
    888957            if ((p->recpriority < (*k)->recpriority && !schedMoveHigher) ||
    889                 !TryAnotherShowing(*k))
     958                !TryAnotherShowing(cardlistmap, titlelistmap,
     959                                   recordidlistmap, *k))
    890960            {
    891                 RestoreRecStatus();
     961                RestoreRecStatus(reclist);
    892962                break;
    893963            }
    894964        }
     
    898968    }
    899969}
    900970
    901 void Scheduler::PruneRedundants(void)
     971bool Scheduler::PruneRedundants(RecList &reclist)
    902972{
    903973    ProgramInfo *lastp = NULL;
    904     hasconflicts = false;
     974    bool hasconflicts = false;
    905975
    906976    RecIter i = reclist.begin();
    907977    while (i != reclist.end())
     
    9511021            i = reclist.erase(i);
    9521022        }
    9531023    }
     1024
     1025    return hasconflicts;
    9541026}
    9551027
    956 void Scheduler::UpdateNextRecord(void)
     1028void Scheduler::UpdateNextRecord(MSqlQueryInfo &dbConn,
     1029                                 RecList       &reclist)
    9571030{
    9581031    QMap<int, QDateTime> nextRecMap;
    9591032    QDateTime now = QDateTime::currentDateTime();
     
    10431116{
    10441117    QMutexLocker lockit(reclist_lock);
    10451118
    1046     while (retList->size() > 0)
    1047     {
    1048         ProgramInfo *pginfo = retList->back();
    1049         delete pginfo;
    1050         retList->pop_back();
    1051     }
    1052 
    1053     RecIter i = reclist.begin();
    1054     for (; i != reclist.end(); i++)
    1055     {
    1056         ProgramInfo *p = *i;
    1057         retList->push_back(new ProgramInfo(*p));
    1058     }
     1119    copy_reclist(*retList, reclist);
    10591120    retList->sort(comp_timechannel);
    10601121}
    10611122
    10621123void Scheduler::getAllPending(QStringList &strList)
    10631124{
    1064     QMutexLocker lockit(reclist_lock);
     1125    RecList retList;
     1126    getAllPending(&retList);
    10651127
    10661128    strList << QString::number(hasconflicts);
    1067     strList << QString::number(reclist.size());
     1129    strList << QString::number(retList.size());
    10681130
    1069     RecList *retList = new RecList;
     1131    for (RecIter it = retList.begin(); it != retList.end(); ++it)
     1132        (*it)->ToStringList(strList);
    10701133
    1071     RecIter i = reclist.begin();
    1072     for (; i != reclist.end(); i++)
    1073     {
    1074         ProgramInfo *p = *i;
    1075         retList->push_back(new ProgramInfo(*p));
    1076     }
    1077     retList->sort(comp_timechannel);
    1078 
    1079     for (i = retList->begin(); i != retList->end(); i++)
    1080     {
    1081         ProgramInfo *p = *i;
    1082         p->ToStringList(strList);
    1083         delete p;
    1084     }
    1085 
    1086     delete retList;
     1134    delete_reclist(retList);
    10871135}
    10881136
    10891137RecList *Scheduler::getAllScheduled(void)
    10901138{
    1091     while (schedlist.size() > 0)
    1092     {
    1093         ProgramInfo *pginfo = schedlist.back();
    1094         delete pginfo;
    1095         schedlist.pop_back();
    1096     }
     1139    delete_reclist(schedlist);
    10971140
    10981141    findAllScheduledPrograms(schedlist);
    10991142
     
    20082051    VERBOSE(VB_SCHEDULE, " +-- Done.");
    20092052}
    20102053
    2011 void Scheduler::AddNewRecords(void)
     2054void Scheduler::AddNewRecords(MSqlQueryInfo           &dbConn,
     2055                              const QString           &recordTable,
     2056                              const bool               specsched,
     2057                              const bool               threadrunning,
     2058                              QMap<int, EncoderLink*> &tvList,
     2059                              RecList                 &reclist)
    20122060{
    20132061    struct timeval dbstart, dbend;
    20142062
     
    20222070    int ccpriority      = gContext->GetNumSetting("CCRecPriority", 0);
    20232071
    20242072    QMap<int, bool> cardMap;
    2025     QMap<int, EncoderLink *>::Iterator enciter = m_tvList->begin();
    2026     for (; enciter != m_tvList->end(); ++enciter)
     2073    QMap<int, EncoderLink *>::Iterator enciter = tvList.begin();
     2074    for (; enciter != tvList.end(); ++enciter)
    20272075    {
    20282076        EncoderLink *enc = enciter.data();
    20292077        if (enc->IsConnected())
     
    23332381                    r->recendts != p->recendts &&
    23342382                    (r->recordid == p->recordid ||
    23352383                     p->rectype == kOverrideRecord))
    2336                     ChangeRecordingEnd(r, p);
     2384                {
     2385                    ChangeRecordingEnd(specsched, tvList, r, p);
     2386                }
    23372387                delete p;
    23382388                p = NULL;
    23392389                break;
     
    23902440        reclist.push_back(*tmp);
    23912441}
    23922442
    2393 void Scheduler::AddNotListed(void) {
    2394 
     2443void Scheduler::AddNotListed(MSqlQueryInfo &dbConn,
     2444                             const QString &recordTable,
     2445                             RecList       &reclist)
     2446{
    23952447    struct timeval dbstart, dbend;
    23962448    RecList tmpList;
    23972449
  • 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
     
    6666    static void *SchedulerThread(void *param);
    6767
    6868  private:
    69     QString recordTable;
    70 
    7169    void verifyCards(void);
    7270
    7371    bool FillRecordList(void);
    7472    void UpdateMatches(int recordid);
    7573    void UpdateManuals(int recordid);
    76     void PruneOldRecords(void);
    77     void AddNewRecords(void);
    78     void AddNotListed(void);
    7974    void BuildNewRecordsQueries(int recordid, QStringList &from, QStringList &where,
    8075                                MSqlBindings &bindings);
    81     void PruneOverlaps(void);
    82     void BuildListMaps(void);
    83     void ClearListMaps(void);
    84     bool FindNextConflict(RecList &cardlist, ProgramInfo *p, RecIter &iter);
    85     void MarkOtherShowings(ProgramInfo *p);
    86     void MarkShowingsList(RecList &showinglist, ProgramInfo *p);
    87     void BackupRecStatus(void);
    88     void RestoreRecStatus(void);
    89     bool TryAnotherShowing(ProgramInfo *p);
    90     void SchedNewRecords(void);
    91     void MoveHigherRecords(void);
    92     void PruneRedundants(void);
    93     void UpdateNextRecord(void);
    9476
    95     bool ChangeRecordingEnd(ProgramInfo *oldp, ProgramInfo *newp);
    96 
    9777    void findAllScheduledPrograms(list<ProgramInfo *> &proglist);
    9878    bool CheckShutdownServer(int prerollseconds, QDateTime &idleSince,
    9979                             bool &blockShutdown);
    10080    void ShutdownServer(int prerollseconds);
    10181
     82    // statics
     83    static void PruneOldRecords(RecList               &reclist);
     84    static void AddNewRecords(MSqlQueryInfo           &dbConn,
     85                              const QString           &recordTable,
     86                              bool                     specsched,
     87                              bool                     threadrunning,
     88                              QMap<int, EncoderLink*> &tvList,
     89                              RecList                 &reclist);
     90    static void AddNotListed(MSqlQueryInfo            &dbConn,
     91                             const QString            &recordTable,
     92                             RecList                  &reclist);
     93    static void PruneOverlaps(RecList                 &reclist);
     94    static void BuildListMaps(RecList                 &reclist,
     95                              QMap<int, RecList>      &cardlistmap,
     96                              QMap<int, RecList>      &recordidlistmap,
     97                              QMap<QString, RecList>  &titlelistmap);
     98    static void ClearListMaps(QMap<int, RecList>      &cardlistmap,
     99                              QMap<int, RecList>      &recordidlistmap,
     100                              QMap<QString, RecList>  &titlelistmap);
     101    static bool FindNextConflict(RecList                   &cardlist,
     102                                 ProgramInfo               *p,
     103                                 RecIter                   &iter);
     104    static void MarkOtherShowings(ProgramInfo              *p,
     105                                  QMap<int, RecList>       &recordidlistmap,
     106                                  QMap<QString, RecList>   &titlelistmap);
     107    static void MarkShowingsList(RecList                   &showinglist,
     108                                 ProgramInfo               *p);
     109    static void BackupRecStatus(RecList                    &reclist);
     110    static void RestoreRecStatus(RecList                   &reclist);
     111    static bool TryAnotherShowing(QMap<int, RecList>       &cardlistmap,
     112                                  QMap<QString, RecList>   &titlelistmap,
     113                                  QMap<int, RecList>       &recordidlistmap,
     114                                  ProgramInfo              *p);
     115    static void SchedNewRecords(bool                        schedMoveHigher,
     116                                RecList                    &reclist,
     117                                RecList                    &retrylist,
     118                                QMap<int, RecList>         &cardlistmap,
     119                                QMap<int, RecList>         &recordidlistmap,
     120                                QMap<QString, RecList>     &titlelistmap);
     121    static void MoveHigherRecords(bool                      schedMoveHigher,
     122                                  RecList                  &reclist,
     123                                  RecList                  &retrylist,
     124                                  QMap<int, RecList>       &cardlistmap,
     125                                  QMap<int, RecList>       &recordidlistmap,
     126                                  QMap<QString, RecList>   &titlelistmap);
     127    static bool PruneRedundants(RecList                    &reclist);
     128    static void UpdateNextRecord(MSqlQueryInfo             &dbConn,
     129                                 RecList                   &reclist);
     130    static bool ChangeRecordingEnd(bool                     specsched,
     131                                   QMap<int, EncoderLink*> &tvList,
     132                                   ProgramInfo             *oldp,
     133                                   ProgramInfo             *newp);
    102134
     135  private:
     136    QString recordTable;
    103137    QValueList<int> reschedQueue;
    104138    QMutex reschedLock;
    105139    QMutex recordmatchLock;
    106140    QWaitCondition reschedWait;
    107141    RecList reclist;
    108     RecList retrylist;
    109142    RecList schedlist;
    110     QMap<int, RecList> cardlistmap;
    111     QMap<int, RecList> recordidlistmap;
    112     QMap<QString, RecList> titlelistmap;
    113143
    114144    QMutex *reclist_lock;
    115145    QMutex *schedlist_lock;