Ticket #2874: encryption_sigmon.diff

File encryption_sigmon.diff, 18.2 KB (added by Janne <janne-mythtv@…>, 17 years ago)

  • mythtv/libs/libmythtv/dtvsignalmonitor.cpp 

    diff --git a/mythtv/libs/libmythtv/dtvsignalmonitor.cpp b/mythtv/libs/libmythtv/dtvsignalmonitor.cpp
index 52ddf2f..b30d44b 100644
    a b  
    11#include <unistd.h>
    22
    33#include "dtvchannel.h"
     4#include "dvbchannel.h"
    45#include "dtvsignalmonitor.h"
    56#include "scanstreamdata.h"
    67#include "mpegtables.h"
    … … DTVSignalMonitor::DTVSignalMonitor(int db_cardnum, 
    3031      seenVCT(tr("Seen")+" VCT", "seen_vct", 1, true, 0, 1, 0),
    3132      seenNIT(tr("Seen")+" NIT", "seen_nit", 1, true, 0, 1, 0),
    3233      seenSDT(tr("Seen")+" SDT", "seen_sdt", 1, true, 0, 1, 0),
     34      seenCrypt(tr("Seen")+" Crypt", "seen_crypt", 1, true, 0, 1, 0),
    3335      matchingPAT(tr("Matching")+" PAT", "matching_pat", 1, true, 0, 1, 0),
    3436      matchingPMT(tr("Matching")+" PMT", "matching_pmt", 1, true, 0, 1, 0),
    3537      matchingMGT(tr("Matching")+" MGT", "matching_mgt", 1, true, 0, 1, 0),
    3638      matchingVCT(tr("Matching")+" VCT", "matching_vct", 1, true, 0, 1, 0),
    3739      matchingNIT(tr("Matching")+" NIT", "matching_nit", 1, true, 0, 1, 0),
    3840      matchingSDT(tr("Matching")+" SDT", "matching_sdt", 1, true, 0, 1, 0),
     41      matchingCrypt(tr("Matching")+" Crypt", "matching_crypt", 1, true, 0, 1, 0),
    3942      majorChannel(-1), minorChannel(-1),
    4043      networkID(0), transportID(0),
    4144      detectedNetworkID(0), detectedTransportID(0),
    … … QStringList DTVSignalMonitor::GetStatusList(bool kick) 
    112115        list<<seenSDT.GetName()<<seenSDT.GetStatus();
    113116        list<<matchingSDT.GetName()<<matchingSDT.GetStatus();
    114117    }
     118    if (flags & kDTVSigMon_WaitForCrypt)
     119    {
     120        list<<seenCrypt.GetName()<<seenCrypt.GetStatus();
     121        list<<matchingCrypt.GetName()<<matchingCrypt.GetStatus();
     122    }
    115123    if (error != "")
    116124    {
    117125        list<<"error"<<error;
    … … void DTVSignalMonitor::UpdateMonitorValues(void) 
    140148    seenVCT.SetValue(    (flags & kDTVSigMon_VCTSeen)  ? 1 : 0);
    141149    seenNIT.SetValue(    (flags & kDTVSigMon_NITSeen)  ? 1 : 0);
    142150    seenSDT.SetValue(    (flags & kDTVSigMon_SDTSeen)  ? 1 : 0);
     151    seenCrypt.SetValue(  (flags & kDTVSigMon_CryptSeen)  ? 1 : 0);
    143152    matchingPAT.SetValue((flags & kDTVSigMon_PATMatch) ? 1 : 0);
    144153    matchingPMT.SetValue((flags & kDTVSigMon_PMTMatch) ? 1 : 0);
    145154    matchingMGT.SetValue((flags & kDTVSigMon_MGTMatch) ? 1 : 0);
    146155    matchingVCT.SetValue((flags & kDTVSigMon_VCTMatch) ? 1 : 0);
    147156    matchingNIT.SetValue((flags & kDTVSigMon_NITMatch) ? 1 : 0);
    148157    matchingSDT.SetValue((flags & kDTVSigMon_SDTMatch) ? 1 : 0);
     158    matchingCrypt.SetValue((flags & kDTVSigMon_CryptMatch) ? 1 : 0);
    149159}
    150160
    151161void DTVSignalMonitor::UpdateListeningForEIT(void)
    … … void DTVSignalMonitor::SetChannel(int major, int minor) 
    179189    {
    180190        RemoveFlags(kDTVSigMon_PATSeen | kDTVSigMon_PATMatch |
    181191                    kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
    182                     kDTVSigMon_VCTSeen | kDTVSigMon_VCTMatch);
     192                    kDTVSigMon_VCTSeen | kDTVSigMon_VCTMatch |
     193                  kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    183194        majorChannel = major;
    184195        minorChannel = minor;
    185196        GetATSCStreamData()->SetDesiredChannel(major, minor);
    … … void DTVSignalMonitor::SetProgramNumber(int progNum) 
    192203    DBG_SM(QString("SetProgramNumber(%1)").arg(progNum), "");
    193204    if (programNumber != progNum)
    194205    {
    195         RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch);
     206        RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
     207                  kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    196208        programNumber = progNum;
    197209        if (GetStreamData())
    198210            GetStreamData()->SetDesiredProgram(programNumber);
    … … void DTVSignalMonitor::SetDVBService(uint netid, uint tsid, int serviceid) 
    212224    }
    213225
    214226    RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
    215                 kDTVSigMon_SDTSeen | kDTVSigMon_SDTMatch);
     227                kDTVSigMon_SDTSeen | kDTVSigMon_SDTMatch |
     228                  kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    216229
    217230    transportID   = tsid;
    218231    networkID     = netid;
    … … void DTVSignalMonitor::HandlePAT(const ProgramAssociationTable *pat) 
    296309
    297310void DTVSignalMonitor::HandlePMT(uint, const ProgramMapTable *pmt)
    298311{
     312    bool test_decryption = false;
    299313    AddFlags(kDTVSigMon_PMTSeen);
    300314
    301315    if (programNumber < 0)
    … … void DTVSignalMonitor::HandlePMT(uint, const ProgramMapTable *pmt) 
    309323        return; // Not the PMT we are looking for...
    310324    }
    311325
    312     if (ignoreEncrypted && pmt->IsEncrypted())
     326    if (pmt->IsEncrypted())
    313327    {
    314         VERBOSE(VB_IMPORTANT, LOC + "Ignoring encrypted program");
    315         return;
     328        if (ignoreEncrypted)
     329        {
     330            VERBOSE(VB_IMPORTANT, LOC + "Ignoring encrypted program");
     331            return;
     332        }
     333        else
     334        {
     335            DVBChannel* dvbchan = dynamic_cast<DVBChannel*>(GetDTVChannel());
     336            if (dvbchan)
     337                dvbchan->SetPMT(pmt);
     338            AddFlags(kDTVSigMon_WaitForCrypt);
     339            test_decryption = true;
     340        }
    316341    }
    317342
    318343    // if PMT contains audio and/or video stream set as matching.
    319344    uint hasAudio = 0;
    320345    uint hasVideo = 0;
     346    bool needVideo = GetStreamData()->GetVideoStreamsRequired();
    321347
    322348    for (uint i = 0; i < pmt->StreamCount(); i++)
    323349    {
    324         hasVideo += pmt->IsVideo(i, GetDTVChannel()->GetSIStandard());
    325         hasAudio += pmt->IsAudio(i, GetDTVChannel()->GetSIStandard());
     350        if (pmt->IsVideo(i, GetDTVChannel()->GetSIStandard()))
     351        {
     352            hasVideo++;
     353            if (needVideo && test_decryption)
     354            {
     355                test_decryption = false;
     356                uint pid = pmt->StreamPID(i);
     357                VERBOSE(VB_RECORD, QString("Trying to decrypt the video stream "
     358                                           "on PID %1.").arg(pid));
     359                GetStreamData()->AddEncryptionTestPID(pid);
     360                GetStreamData()->AddListeningPID(pid);
     361            }
     362        }
     363        if (pmt->IsAudio(i, GetDTVChannel()->GetSIStandard()))
     364        {
     365            hasAudio++;
     366            if (!needVideo && test_decryption)
     367            {
     368                test_decryption = false;
     369                uint pid = pmt->StreamPID(i);
     370                VERBOSE(VB_RECORD, QString("Trying to decrypt the audio stream "
     371                                           "on PID %1.").arg(pid));
     372                GetStreamData()->AddEncryptionTestPID(pid);
     373                GetStreamData()->AddListeningPID(pid);
     374            }
     375        }
    326376    }
    327377
    328378    if ((hasVideo >= GetStreamData()->GetVideoStreamsRequired()) &&
    … … void DTVSignalMonitor::HandleSDT(uint, const ServiceDescriptionTable *sdt) 
    432482    }
    433483}
    434484
     485void DTVSignalMonitor::HandleEncryptionStatus(uint pid, bool enc_status)
     486{
     487
     488    AddFlags(kDTVSigMon_CryptSeen);
     489    if (!enc_status)
     490    {
     491        VERBOSE(VB_RECORD, QString("Stream on PID %1 is unencrypted").arg(pid));
     492        GetStreamData()->RemoveEncryptionTestPID(pid);
     493        GetStreamData()->RemoveListeningPID(pid);
     494        //RemoveFlags(kDTVSigMon_WaitForCrypt);
     495        AddFlags(kDTVSigMon_CryptMatch);
     496    }
     497}
     498
    435499ATSCStreamData *DTVSignalMonitor::GetATSCStreamData()
    436500{
    437501    return dynamic_cast<ATSCStreamData*>(stream_data);
    … … bool DTVSignalMonitor::IsAllGood(void) const 
    479543            return false;
    480544    if ((flags & kDTVSigMon_WaitForSDT) && !matchingSDT.IsGood())
    481545            return false;
     546    if ((flags & kDTVSigMon_WaitForCrypt) && !matchingCrypt.IsGood())
     547            return false;
    482548
    483549    return true;
    484550}

  • mythtv/libs/libmythtv/dtvsignalmonitor.h 

    diff --git a/mythtv/libs/libmythtv/dtvsignalmonitor.h b/mythtv/libs/libmythtv/dtvsignalmonitor.h
index 4547b22..d52225e 100644
    a b class DTVSignalMonitor : public SignalMonitor, 
    8686    void HandlePAT(const ProgramAssociationTable*);
    8787    void HandleCAT(const ConditionalAccessTable*) {}
    8888    void HandlePMT(uint, const ProgramMapTable*);
     89    void HandleEncryptionStatus(uint, bool enc_status);
    8990
    9091    // ATSC Main
    9192    void HandleSTT(const SystemTimeTable*) {}
    … … class DTVSignalMonitor : public SignalMonitor, 
    118119    SignalMonitorValue seenVCT;
    119120    SignalMonitorValue seenNIT;
    120121    SignalMonitorValue seenSDT;
     122    SignalMonitorValue seenCrypt;
    121123    SignalMonitorValue matchingPAT;
    122124    SignalMonitorValue matchingPMT;
    123125    SignalMonitorValue matchingMGT;
    124126    SignalMonitorValue matchingVCT;
    125127    SignalMonitorValue matchingNIT;
    126128    SignalMonitorValue matchingSDT;
     129    SignalMonitorValue matchingCrypt;
    127130
    128131    // ATSC tuning info
    129132    int                majorChannel;

  • mythtv/libs/libmythtv/dvbrecorder.h 

    diff --git a/mythtv/libs/libmythtv/dvbrecorder.h b/mythtv/libs/libmythtv/dvbrecorder.h
index 69fba97..7104af2 100644
    a b class DVBRecorder : public DTVRecorder, 
    8181    void HandlePAT(const ProgramAssociationTable*);
    8282    void HandleCAT(const ConditionalAccessTable*) {}
    8383    void HandlePMT(uint pid, const ProgramMapTable*);
     84    void HandleEncryptionStatus(uint, bool) { }
    8485
    8586    void SetStreamData(MPEGStreamData*);
    8687    MPEGStreamData* GetStreamData(void) { return _stream_data; }

  • mythtv/libs/libmythtv/mpeg/mpegstreamdata.cpp 

    diff --git a/mythtv/libs/libmythtv/mpeg/mpegstreamdata.cpp b/mythtv/libs/libmythtv/mpeg/mpegstreamdata.cpp
index 246ef84..a6eee70 100644
    a b bool MPEGStreamData::ProcessTSPacket(const TSPacket& tspacket) 
    728728{
    729729    bool ok = !tspacket.TransportError();
    730730    if (ok && !tspacket.ScramplingControl() && tspacket.HasPayload() &&
    731         IsListeningPID(tspacket.PID()))
     731        IsListeningPID(tspacket.PID()) && !IsEncryptionTestPID(tspacket.PID()))
    732732    {
    733733        HandleTSTables(&tspacket);
    734734    }
     735    else if (IsEncryptionTestPID(tspacket.PID()))
     736    {       
     737        _listener_lock.lock();
     738        for (uint i = 0; i < _mpeg_listeners.size(); i++)
     739            _mpeg_listeners[i]->HandleEncryptionStatus(tspacket.PID(),
     740                                                       tspacket.ScramplingControl());
     741        _listener_lock.unlock();
     742    }
     743
    735744    return ok;
    736745}
    737746
    … … bool MPEGStreamData::IsAudioPID(uint pid) const 
    778787    return it != _pids_audio.end();
    779788}
    780789
     790bool MPEGStreamData::IsEncryptionTestPID(uint pid) const
     791{
     792    QMap<uint, bool>::const_iterator it = _pids_encryption.find(pid);
     793    return it != _pids_encryption.end();
     794}
     795
    781796void MPEGStreamData::SavePartialPES(uint pid, PESPacket* packet)
    782797{
    783798    pid_pes_map_t::iterator it = _partial_pes_packet_cache.find(pid);

  • mythtv/libs/libmythtv/mpeg/mpegstreamdata.h 

    diff --git a/mythtv/libs/libmythtv/mpeg/mpegstreamdata.h b/mythtv/libs/libmythtv/mpeg/mpegstreamdata.h
index fd053a2..9b6c46f 100644
    a b class MPEGStreamData : public EITSource 
    7474    virtual void AddNotListeningPID(uint pid){_pids_notlistening[pid] = true;}
    7575    virtual void AddWritingPID(uint pid)    { _pids_writing[pid] = true;   }
    7676    virtual void AddAudioPID(uint pid)      { _pids_audio[pid] = true;     }
     77    virtual void AddEncryptionTestPID(uint pid) { _pids_encryption[pid] = true;}
    7778
    7879    virtual void RemoveListeningPID(uint pid) { _pids_listening.erase(pid);  }
    7980    virtual void RemoveNotListeningPID(uint pid)
    8081        { _pids_notlistening.erase(pid); }
    8182    virtual void RemoveWritingPID(uint pid) { _pids_writing.erase(pid);    }
    8283    virtual void RemoveAudioPID(uint pid)   { _pids_audio.erase(pid);      }
     84    virtual void RemoveEncryptionTestPID(uint pid) { _pids_encryption.erase(pid);}
    8385
    8486    virtual bool IsListeningPID(uint pid) const;
    8587    virtual bool IsNotListeningPID(uint pid) const;
    8688    virtual bool IsWritingPID(uint pid) const;
    8789    virtual bool IsAudioPID(uint pid) const;
     90    virtual bool IsEncryptionTestPID(uint pid) const;
    8891
    8992    virtual QMap<uint, bool> ListeningPIDs(void) const
    9093        { return _pids_listening; }
    9194
     95    virtual QMap<uint, bool> EncryptionTestPID(void) const
     96        { return _pids_encryption; }
     97
     98
    9299    // Table versions
    93100    void SetVersionPAT(uint tsid, int version, uint last_section)
    94101    {
    … … class MPEGStreamData : public EITSource 
    237244    QMap<uint, bool>          _pids_notlistening;
    238245    QMap<uint, bool>          _pids_writing;
    239246    QMap<uint, bool>          _pids_audio;
     247    QMap<uint, bool>          _pids_encryption;
    240248
    241249    // Signals
    242250    mutable QMutex            _listener_lock;

  • mythtv/libs/libmythtv/mpeg/streamlisteners.h 

    diff --git a/mythtv/libs/libmythtv/mpeg/streamlisteners.h b/mythtv/libs/libmythtv/mpeg/streamlisteners.h
index 7a719ec..a884b00 100644
    a b  
     1// -*- Mode: c++ -*-
    12#ifndef _STREAMLISTENERS_H_
    23#define _STREAMLISTENERS_H_
    34
    … … class MPEGStreamListener 
    4142    virtual void HandlePAT(const ProgramAssociationTable*) = 0;
    4243    virtual void HandleCAT(const ConditionalAccessTable*) = 0;
    4344    virtual void HandlePMT(uint program_num, const ProgramMapTable*) = 0;
     45    virtual void HandleEncryptionStatus(uint pid, bool) = 0;
    4446};
    4547
    4648class MPEGSingleProgramStreamListener

  • mythtv/libs/libmythtv/signalmonitor.h 

    diff --git a/mythtv/libs/libmythtv/signalmonitor.h b/mythtv/libs/libmythtv/signalmonitor.h
index 0ecb13a..80aa7cb 100644
    a b class SignalMonitor : public QObject 
    148148    static const uint64_t kDTVSigMon_SDTSeen    = 0x0000000080ULL;
    149149    /// We've seen the FireWire STB power state
    150150    static const uint64_t kFWSigMon_PowerSeen   = 0x0000000100ULL;
     151    /// We can encrypt the stream
     152    static const uint64_t kDTVSigMon_CryptSeen  = 0x0000000200ULL;
    151153
    152154    /// We've seen a PAT matching our requirements
    153155    static const uint64_t kDTVSigMon_PATMatch   = 0x0000001000ULL;
    … … class SignalMonitor : public QObject 
    167169    static const uint64_t kDTVSigMon_SDTMatch   = 0x0000080000ULL;
    168170    /// We've seen a FireWire STB power state matching our requirements
    169171    static const uint64_t kFWSigMon_PowerMatch  = 0x0000100000ULL;
     172    /// We can encrypt the stream
     173    static const uint64_t kDTVSigMon_CryptMatch = 0x0000200000ULL;
    170174
    171175    static const uint64_t kDTVSigMon_WaitForPAT = 0x0001000000ULL;
    172176    static const uint64_t kDTVSigMon_WaitForPMT = 0x0002000000ULL;
    … … class SignalMonitor : public QObject 
    176180    static const uint64_t kDTVSigMon_WaitForSDT = 0x0020000000ULL;
    177181    static const uint64_t kDTVSigMon_WaitForSig = 0x0040000000ULL;
    178182    static const uint64_t kFWSigMon_WaitForPower= 0x0080000000ULL;
     183    static const uint64_t kDTVSigMon_WaitForCrypt= 0x1000000000ULL;
    179184
    180     static const uint64_t kDTVSigMon_WaitForAll = 0x00FF000000ULL;
     185    static const uint64_t kDTVSigMon_WaitForAll = 0x10FF000000ULL;
    181186
    182187    /// Wait for the Signal to Noise Ratio to rise above a threshhold
    183188    static const uint64_t kDVBSigMon_WaitForSNR = 0x0100000000ULL;
    … … inline QString sm_flags_to_string(uint64_t flags) 
    228233        str += "SDT,";
    229234    if (SignalMonitor::kFWSigMon_PowerSeen   & flags)
    230235        str += "STB,";
     236    if (SignalMonitor::kDTVSigMon_CryptSeen  & flags)
     237        str += "Crypt,";
    231238
    232239    str += ") Match(";
    233240    if (SignalMonitor::kDTVSigMon_PATMatch   & flags)
    … … inline QString sm_flags_to_string(uint64_t flags) 
    248255        str += "SDT,";
    249256    if (SignalMonitor::kFWSigMon_PowerMatch  & flags)
    250257        str += "STB,";
     258    if (SignalMonitor::kDTVSigMon_CryptMatch & flags)
     259        str += "Crypt,";
    251260
    252261    str += ") Wait(";
    253262    if (SignalMonitor::kDTVSigMon_WaitForPAT & flags)
    … … inline QString sm_flags_to_string(uint64_t flags) 
    266275        str += "Sig,";
    267276    if (SignalMonitor::kFWSigMon_WaitForPower& flags)
    268277        str += "STB,";
     278    if (SignalMonitor::kDTVSigMon_WaitForCrypt & flags)
     279        str += "Crypt,";
    269280
    270281    if (SignalMonitor::kDVBSigMon_WaitForSNR & flags)
    271282        str += "SNR,";

  • mythtv/libs/libmythtv/signalmonitorvalue.h 

    diff --git a/mythtv/libs/libmythtv/signalmonitorvalue.h b/mythtv/libs/libmythtv/signalmonitorvalue.h
index 67d1d52..ef0e296 100644
    a b  
     1// -*- Mode: c++ -*-
    12#ifndef SIGNALMONITORVALUES_H
    23#define SIGNALMONITORVALUES_H
    34

  • mythtv/libs/libmythtv/siscan.h 

    diff --git a/mythtv/libs/libmythtv/siscan.h b/mythtv/libs/libmythtv/siscan.h
index 9af8abc..044eb96 100644
    a b class SIScan : public QObject, 
    8585    void HandlePAT(const ProgramAssociationTable*);
    8686    void HandleCAT(const ConditionalAccessTable*) { }
    8787    void HandlePMT(uint, const ProgramMapTable*) { }
     88    void HandleEncryptionStatus(uint, bool) { }
    8889
    8990    // ATSC Main
    9091    void HandleSTT(const SystemTimeTable*) {}

  • mythtv/libs/libmythtv/tv_play.cpp 

    diff --git a/mythtv/libs/libmythtv/tv_play.cpp b/mythtv/libs/libmythtv/tv_play.cpp
index 34ff5eb..2959ecf 100644
    a b void TV::UpdateOSDSignal(const QStringList& strlist) 
    46864686    float snr  = 0.0f;
    46874687    uint  ber  = 0xffffffff;
    46884688    int   pos  = -1;
    4689     QString pat(""), pmt(""), mgt(""), vct(""), nit(""), sdt("");
     4689    QString pat(""), pmt(""), mgt(""), vct(""), nit(""), sdt(""), crypt("");
    46904690    QString err = QString::null, msg = QString::null;
    46914691    for (it = slist.begin(); it != slist.end(); ++it)
    46924692    {
    … … void TV::UpdateOSDSignal(const QStringList& strlist) 
    47364736            sdt = it->IsGood() ? "s" : "_";
    47374737        else if ("matching_sdt" == it->GetShortName())
    47384738            sdt = it->IsGood() ? "S" : sdt;
     4739        else if ("seen_crypt" == it->GetShortName())
     4740            crypt = it->IsGood() ? "c" : "_";
     4741        else if ("matching_crypt" == it->GetShortName())
     4742            crypt = it->IsGood() ? "C" : crypt;
    47394743    }
    47404744    if (sig)
    47414745        infoMap["signal"] = QString::number(sig); // use normalized value
    … … void TV::UpdateOSDSignal(const QStringList& strlist) 
    47534757    if ((pos >= 0) && (pos < 100))
    47544758        sigDesc += " | " + tr("Rotor %1\%").arg(pos,2);
    47554759
    4756     sigDesc = sigDesc + QString(" | (%1%2%3%4%5%6%7) %8")
     4760    sigDesc = sigDesc + QString(" | (%1%2%3%4%5%6%7%8) %9")
    47574761        .arg(slock).arg(pat).arg(pmt).arg(mgt).arg(vct)
    4758         .arg(nit).arg(sdt).arg(sigMsg);
     4762        .arg(nit).arg(sdt).arg(crypt).arg(sigMsg);
    47594763
    47604764    if (!err.isEmpty())
    47614765        sigDesc = err;