Ticket #11018: 20201230-trac11018.patch

File 20201230-trac11018.patch, 7.9 KB (added by Klaas de Waal, 10 months ago)

Active EIT scan only when backend is idle, updated to compile against master of 20201230

  • mythtv/libs/libmythtv/tv_rec.cpp

    diff --git a/mythtv/libs/libmythtv/tv_rec.cpp b/mythtv/libs/libmythtv/tv_rec.cpp
    index 9c538f6a1e..b27b815cdb 100644
    a b void TVRec::FinishedRecording(RecordingInfo *curRec, RecordingQuality *recq) 
    998998 *   to the kState_None state, as this is used to shutdown TV in RunTV.
    999999 *
    10001000 */
     1001
    10011002void TVRec::HandleStateChange(void)
    10021003{
    10031004    TVState nextState = m_internalState;
    void TVRec::HandleStateChange(void) 
    10301031    if (TRANSITION(kState_None, kState_WatchingLiveTV))
    10311032    {
    10321033        m_tuningRequests.enqueue(TuningRequest(kFlagLiveTV));
     1034        SetEITScanPaused();         // KdW test -- #11018
    10331035        SET_NEXT();
    10341036    }
    10351037    else if (TRANSITION(kState_WatchingLiveTV, kState_None))
    10361038    {
    10371039        m_tuningRequests.enqueue(TuningRequest(kFlagKillRec|kFlagKillRingBuffer));
     1040        ClearEITScanPaused();       // KdW test -- #11018
    10381041        SET_NEXT();
    10391042    }
    10401043    else if (TRANSITION(kState_WatchingLiveTV, kState_RecordingOnly))
    10411044    {
    10421045        SetPseudoLiveTVRecording(nullptr);
    1043 
     1046        SetEITScanPaused();         // KdW test -- #11018
    10441047        SET_NEXT();
    10451048    }
    10461049    else if (TRANSITION(kState_None, kState_RecordingOnly))
    10471050    {
    10481051        SetPseudoLiveTVRecording(nullptr);
    10491052        m_tuningRequests.enqueue(TuningRequest(kFlagRecording, m_curRecording));
     1053        SetEITScanPaused();         // KdW test -- #11018
    10501054        SET_NEXT();
    10511055    }
    10521056    else if (TRANSITION(kState_RecordingOnly, kState_None))
    void TVRec::HandleStateChange(void) 
    10541058        m_tuningRequests.enqueue(
    10551059            TuningRequest(kFlagCloseRec|kFlagKillRingBuffer|
    10561060                          (GetFlags()&kFlagKillRec)));
     1061        ClearEITScanPaused();       // KdW test -- #11018
    10571062        SET_NEXT();
    10581063    }
    10591064
    void TVRec::CloseChannel(void) 
    11741179         CardUtil::IsV4L(m_genOpt.m_inputType)))
    11751180    {
    11761181        m_channel->Close();
     1182
     1183        // KdW test -- #11018
     1184        LOG(VB_GENERAL, LOG_INFO, LOC + QString("#11018 Close Card %1")
     1185            .arg(CardUtil::ProbeDVBFrontendName(CardUtil::GetVideoDevice(m_inputId))));
    11771186    }
    11781187}
    11791188
    static int eit_start_rand(uint inputId, int eitTransportTimeout) 
    12651274    return timeout;
    12661275}
    12671276
     1277// ============================================================================
     1278
     1279// KdW test -- #11018
     1280QMutex            TVRec::s_eitInputsLock;
     1281std::vector<uint> TVRec::s_eitInputs;
     1282
     1283// Add EIT scanning input to list
     1284//
     1285void TVRec::AddEITScanInput(void)
     1286{
     1287    QMutexLocker eitLock(&s_eitInputsLock);
     1288    s_eitInputs.push_back(m_inputId);
     1289    for (auto id : std::as_const(s_eitInputs))
     1290    {
     1291        LOG(VB_GENERAL, LOG_INFO, QString("KdW added %1  s_eitInputs:%2").arg(m_inputId).arg(id));
     1292    }
     1293}
     1294
     1295// Pause active EIT scanning on all other inputs
     1296//
     1297void TVRec::SetEITScanPaused(void)
     1298{
     1299    QMutexLocker eitLock(&s_eitInputsLock);
     1300    for (auto id : std::as_const(s_eitInputs))
     1301    {
     1302        if (id != m_inputId)
     1303        {
     1304            TVRec *rec = GetTVRec(id);
     1305            if (rec && !rec->HasFlags(kFlagEITScanPaused))
     1306            {
     1307                rec->SetFlags(kFlagEITScanPaused, __FILE__, __LINE__);
     1308            }
     1309        }
     1310    }
     1311}
     1312
     1313// Resume active EIT scanning on all other inputs
     1314//
     1315void TVRec::ClearEITScanPaused(void)
     1316{
     1317    m_eitScanStartTime = QDateTime::currentDateTime();
     1318    TVRec *arec = nullptr;
     1319    QMutexLocker eitLock(&s_eitInputsLock);
     1320    for (auto id : std::as_const(s_eitInputs))
     1321    {
     1322        if (id != m_inputId)
     1323        {
     1324            TVRec *rec = GetTVRec(id);
     1325            if (!HasFlags(kFlagEITScanPaused))
     1326            {
     1327                if (rec && rec->HasFlags(kFlagEITScanPaused))
     1328                {
     1329                    rec->m_eitScanStartTime = m_eitScanStartTime.addSecs(
     1330                        m_eitCrawlIdleStart + eit_start_rand(id, m_eitTransportTimeout));
     1331                    rec->ClearFlags(kFlagEITScanPaused, __FILE__, __LINE__);
     1332                    LOG(VB_IDLE, LOG_INFO, LOC + "Start EIT-ActiveScan idle-timer for " +
     1333                        QString("input %1, next start time: ").arg(id) +
     1334                            rec->m_eitScanStartTime.toString(Qt::ISODate));
     1335                }
     1336            }
     1337            else if (rec && rec->GetState() != kState_None)
     1338            {
     1339                arec = rec;
     1340            }
     1341        }
     1342    }
     1343    if (arec)
     1344    {
     1345        arec->ClearFlags(kFlagEITScanPaused, __FILE__, __LINE__);
     1346    }
     1347}
     1348// ============================================================================
     1349
    12681350/// \brief Event handling method, contains event loop.
    12691351void TVRec::run(void)
    12701352{
    void TVRec::run(void) 
    12821364        m_scanner = new EITScanner(m_inputId);
    12831365        m_eitScanStartTime = m_eitScanStartTime.addSecs(
    12841366            m_eitCrawlIdleStart + eit_start_rand(m_inputId, m_eitTransportTimeout));
     1367
     1368        AddEITScanInput();          // KdW test -- #11018
    12851369    }
    12861370    else
    12871371    {
    void TVRec::run(void) 
    14251509            ClearFlags(kFlagExitPlayer, __FILE__, __LINE__);
    14261510        }
    14271511
     1512        // if (m_scanner && m_channel &&
     1513        //     MythDate::current() > m_eitScanStartTime)
    14281514        if (m_scanner && m_channel &&
    1429             MythDate::current() > m_eitScanStartTime)
     1515            MythDate::current() > m_eitScanStartTime &&
     1516            !HasFlags(kFlagEITScanPaused))                          // KdW test -- #11018
    14301517        {
    14311518            if (!m_dvbOpt.m_dvbEitScan)
    14321519            {
    void TVRec::run(void) 
    14621549                else
    14631550                {
    14641551                    LOG(VB_EIT, LOG_INFO, LOC + QString(
    1465                             "Postponing EIT scan on input [%1] "
     1552                            "Postponing EIT scan on input %1 "
    14661553                            "because input %2 is busy")
    14671554                        .arg(m_inputId).arg(busy_input.m_inputId));
    14681555                    m_eitScanStartTime = m_eitScanStartTime.addSecs(300);
    void TVRec::run(void) 
    14711558            }
    14721559        }
    14731560
     1561        // KdW test -- #11018
     1562        // Stop EIT-Scanning if pause requested
     1563        if (m_scanner && HasFlags(kFlagEITScanPaused) &&
     1564            HasFlags(kFlagEITScannerRunning))
     1565        {
     1566            m_scanner->StopActiveScan();
     1567            ClearFlags(kFlagEITScannerRunning, __FILE__, __LINE__);
     1568            TuningShutdowns(TuningRequest(kFlagNoRec));
     1569        }
     1570
    14741571        // We should be no more than a few thousand milliseconds,
    14751572        // as the end recording code does not have a trigger...
    14761573        // NOTE: If you change anything here, make sure that
    QString TVRec::FlagToString(uint f) 
    44544551        msg += "Errored,";
    44554552    if (kFlagCancelNextRecording & f)
    44564553        msg += "CancelNextRecording,";
     4554    if (kFlagEITScanPaused & f)             // KdW test -- #11018
     4555        msg += "EITScanPaused,";
    44574556
    44584557    // Tuning flags
    44594558    if ((kFlagRec & f) == kFlagRec)
  • mythtv/libs/libmythtv/tv_rec.h

    diff --git a/mythtv/libs/libmythtv/tv_rec.h b/mythtv/libs/libmythtv/tv_rec.h
    index 0c0a5def09..71bace40b0 100644
    a b class MTV_PUBLIC TVRec : public SignalMonitorListener, public QRunnable 
    436436    static const uint kFlagFinishRecording      = 0x00000008;
    437437    static const uint kFlagErrored              = 0x00000010;
    438438    static const uint kFlagCancelNextRecording  = 0x00000020;
     439    static const uint kFlagEITScanPaused        = 0x00000040; // KdW test - #11018
    439440
    440441    // Tuning flags
    441442    /// final result desired is LiveTV recording
    class MTV_PUBLIC TVRec : public SignalMonitorListener, public QRunnable 
    475476    // Tuning state
    476477    static const uint kFlagRingBufferReady      = 0x40000000;
    477478    static const uint kFlagDetect               = 0x80000000;
     479
     480    // KdW test -- #11018
     481  public:
     482    static QMutex            s_eitInputsLock;
     483    static std::vector<uint> s_eitInputs;
     484    void AddEITScanInput(void);
     485    void SetEITScanPaused(void);
     486    void ClearEITScanPaused(void);
     487
    478488};
    479489
    480490#endif