Ticket #2874: 2874-v1.patch

File 2874-v1.patch, 17.1 KB (added by danielk, 17 years ago)

Minor formatting + compilation fix for HDHomeRun

  • libs/libmythtv/dvbrecorder.h

     
    7878    bool IsOpen(void) const { return _stream_fd >= 0; }
    7979    void Close(void);
    8080
     81    // MPEG Stream Listener
    8182    void HandlePAT(const ProgramAssociationTable*);
    8283    void HandleCAT(const ConditionalAccessTable*) {}
    8384    void HandlePMT(uint pid, const ProgramMapTable*);
     85    void HandleEncryptionStatus(uint pid, bool encrypted) { }
    8486
    8587    void SetStreamData(MPEGStreamData*);
    8688    MPEGStreamData* GetStreamData(void) { return _stream_data; }

  • libs/libmythtv/hdhrrecorder.h

     
    4646    void HandlePAT(const ProgramAssociationTable*);
    4747    void HandleCAT(const ConditionalAccessTable*) {}
    4848    void HandlePMT(uint pid, const ProgramMapTable*);
     49    void HandleEncryptionStatus(uint pid, bool encrypted) { }
    4950
    5051    // MPEG Single Program Stream Listener
    5152    void HandleSingleProgramPAT(ProgramAssociationTable *pat);

  • libs/libmythtv/signalmonitor.h

     
    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;
    … …  
    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;
    … …  
    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;
    … …  
    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)
    … …  
    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)
    … …  
    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,";

  • libs/libmythtv/mpeg/mpegstreamdata.cpp

     
    727727bool MPEGStreamData::ProcessTSPacket(const TSPacket& tspacket)
    728728{
    729729    bool ok = !tspacket.TransportError();
     730
     731    if (ok && IsEncryptionTestPID(tspacket.PID()))
     732    {
     733        QMutexLocker locker(&_listener_lock);
     734        for (uint i = 0; i < _mpeg_listeners.size(); i++)
     735        {
     736            _mpeg_listeners[i]->HandleEncryptionStatus(
     737                tspacket.PID(), tspacket.ScramplingControl());
     738        }
     739    }
     740
    730741    if (ok && !tspacket.ScramplingControl() && tspacket.HasPayload() &&
    731742        IsListeningPID(tspacket.PID()))
    732743    {
    733744        HandleTSTables(&tspacket);
    734745    }
     746
    735747    return ok;
    736748}
    737749
    … …  
    778790    return it != _pids_audio.end();
    779791}
    780792
     793bool MPEGStreamData::IsEncryptionTestPID(uint pid) const
     794{
     795    QMap<uint, bool>::const_iterator it = _pids_encryption.find(pid);
     796    return it != _pids_encryption.end();
     797}
     798
    781799void MPEGStreamData::SavePartialPES(uint pid, PESPacket* packet)
    782800{
    783801    pid_pes_map_t::iterator it = _partial_pes_packet_cache.find(pid);

  • libs/libmythtv/mpeg/streamlisteners.h

     
     1// -*- Mode: c++ -*-
    12#ifndef _STREAMLISTENERS_H_
    23#define _STREAMLISTENERS_H_
    34
    … …  
    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 encrypted) = 0;
    4446};
    4547
    4648class MPEGSingleProgramStreamListener

  • libs/libmythtv/mpeg/mpegstreamdata.h

     
    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    {
    … …  
    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;

  • libs/libmythtv/tv_play.cpp

     
    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    {
    … …  
    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
    … …  
    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;

  • libs/libmythtv/siscan.h

     
    8585    void HandlePAT(const ProgramAssociationTable*);
    8686    void HandleCAT(const ConditionalAccessTable*) { }
    8787    void HandlePMT(uint, const ProgramMapTable*) { }
     88    void HandleEncryptionStatus(uint pid, bool encrypted) { }
    8889
    8990    // ATSC Main
    9091    void HandleSTT(const SystemTimeTable*) {}

  • libs/libmythtv/dtvsignalmonitor.h

     
    8686    void HandlePAT(const ProgramAssociationTable*);
    8787    void HandleCAT(const ConditionalAccessTable*) {}
    8888    void HandlePMT(uint, const ProgramMapTable*);
     89    void HandleEncryptionStatus(uint pid, bool encrypted);
    8990
    9091    // ATSC Main
    9192    void HandleSTT(const SystemTimeTable*) {}
    … …  
    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;

  • libs/libmythtv/dtvsignalmonitor.cpp

     
    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"
    … …  
    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",
     42                    1, true, 0, 1, 0),
    3943      majorChannel(-1), minorChannel(-1),
    4044      networkID(0), transportID(0),
    4145      detectedNetworkID(0), detectedTransportID(0),
    … …  
    9094        }
    9195#endif
    9296    }
     97    if (flags & kDTVSigMon_WaitForCrypt)
     98    {
     99        list<<seenCrypt.GetName()<<seenCrypt.GetStatus();
     100        list<<matchingCrypt.GetName()<<matchingCrypt.GetStatus();
     101    }
    93102    // atsc tables
    94103    if (flags & kDTVSigMon_WaitForMGT)
    95104    {
    … …  
    140149    seenVCT.SetValue(    (flags & kDTVSigMon_VCTSeen)  ? 1 : 0);
    141150    seenNIT.SetValue(    (flags & kDTVSigMon_NITSeen)  ? 1 : 0);
    142151    seenSDT.SetValue(    (flags & kDTVSigMon_SDTSeen)  ? 1 : 0);
     152    seenCrypt.SetValue(  (flags & kDTVSigMon_CryptSeen)? 1 : 0);
    143153    matchingPAT.SetValue((flags & kDTVSigMon_PATMatch) ? 1 : 0);
    144154    matchingPMT.SetValue((flags & kDTVSigMon_PMTMatch) ? 1 : 0);
    145155    matchingMGT.SetValue((flags & kDTVSigMon_MGTMatch) ? 1 : 0);
    146156    matchingVCT.SetValue((flags & kDTVSigMon_VCTMatch) ? 1 : 0);
    147157    matchingNIT.SetValue((flags & kDTVSigMon_NITMatch) ? 1 : 0);
    148158    matchingSDT.SetValue((flags & kDTVSigMon_SDTMatch) ? 1 : 0);
     159    matchingCrypt.SetValue((flags & kDTVSigMon_CryptMatch) ? 1 : 0);
    149160}
    150161
    151162void DTVSignalMonitor::UpdateListeningForEIT(void)
    … …  
    179190    {
    180191        RemoveFlags(kDTVSigMon_PATSeen | kDTVSigMon_PATMatch |
    181192                    kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
    182                     kDTVSigMon_VCTSeen | kDTVSigMon_VCTMatch);
     193                    kDTVSigMon_VCTSeen | kDTVSigMon_VCTMatch |
     194                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    183195        majorChannel = major;
    184196        minorChannel = minor;
    185197        GetATSCStreamData()->SetDesiredChannel(major, minor);
    … …  
    192204    DBG_SM(QString("SetProgramNumber(%1)").arg(progNum), "");
    193205    if (programNumber != progNum)
    194206    {
    195         RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch);
     207        RemoveFlags(kDTVSigMon_PMTSeen   | kDTVSigMon_PMTMatch |
     208                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    196209        programNumber = progNum;
    197210        if (GetStreamData())
    198211            GetStreamData()->SetDesiredProgram(programNumber);
    … …  
    212225    }
    213226
    214227    RemoveFlags(kDTVSigMon_PMTSeen | kDTVSigMon_PMTMatch |
    215                 kDTVSigMon_SDTSeen | kDTVSigMon_SDTMatch);
     228                kDTVSigMon_SDTSeen | kDTVSigMon_SDTMatch |
     229                kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    216230
    217231    transportID   = tsid;
    218232    networkID     = netid;
    … …  
    296310
    297311void DTVSignalMonitor::HandlePMT(uint, const ProgramMapTable *pmt)
    298312{
     313    bool test_decryption = false;
    299314    AddFlags(kDTVSigMon_PMTSeen);
    300315
    301316    if (programNumber < 0)
    … …  
    309324        return; // Not the PMT we are looking for...
    310325    }
    311326
    312     if (ignoreEncrypted && pmt->IsEncrypted())
     327    if (pmt->IsEncrypted())
    313328    {
    314         VERBOSE(VB_IMPORTANT, LOC + "Ignoring encrypted program");
    315         return;
     329        if (ignoreEncrypted)
     330        {
     331            VERBOSE(VB_IMPORTANT, LOC + "Ignoring encrypted program");
     332            return;
     333        }
     334        else
     335        {
     336            DVBChannel *dvbchan = dynamic_cast<DVBChannel*>(GetDTVChannel());
     337            if (dvbchan)
     338                dvbchan->SetPMT(pmt);
     339
     340            AddFlags(kDTVSigMon_WaitForCrypt);
     341            test_decryption = true;
     342        }
    316343    }
    317344
    318345    // if PMT contains audio and/or video stream set as matching.
    319346    uint hasAudio = 0;
    320347    uint hasVideo = 0;
     348    bool needVideo = GetStreamData()->GetVideoStreamsRequired();
    321349
    322350    for (uint i = 0; i < pmt->StreamCount(); i++)
    323351    {
    324         hasVideo += pmt->IsVideo(i, GetDTVChannel()->GetSIStandard());
    325         hasAudio += pmt->IsAudio(i, GetDTVChannel()->GetSIStandard());
     352        if (pmt->IsVideo(i, GetDTVChannel()->GetSIStandard()))
     353        {
     354            hasVideo++;
     355            if (needVideo && test_decryption)
     356            {
     357                test_decryption = false;
     358                uint pid = pmt->StreamPID(i);
     359                VERBOSE(VB_RECORD, LOC +
     360                        QString("Trying to decrypt the video stream "
     361                                "on PID 0x%1.").arg(pid,0,16));
     362                GetStreamData()->AddEncryptionTestPID(pid);
     363                GetStreamData()->AddListeningPID(pid);
     364            }
     365        }
     366        if (pmt->IsAudio(i, GetDTVChannel()->GetSIStandard()))
     367        {
     368            hasAudio++;
     369            if (!needVideo && test_decryption)
     370            {
     371                test_decryption = false;
     372                uint pid = pmt->StreamPID(i);
     373                VERBOSE(VB_RECORD, LOC +
     374                        QString("Trying to decrypt the audio stream "
     375                                "on PID 0x%1.").arg(pid,0,16));
     376                GetStreamData()->AddEncryptionTestPID(pid);
     377                GetStreamData()->AddListeningPID(pid);
     378            }
     379        }
    326380    }
    327381
    328382    if ((hasVideo >= GetStreamData()->GetVideoStreamsRequired()) &&
    … …  
    432486    }
    433487}
    434488
     489void DTVSignalMonitor::HandleEncryptionStatus(uint pid, bool encrypted)
     490{
     491    AddFlags(kDTVSigMon_CryptSeen);
     492    if (!encrypted)
     493    {
     494        VERBOSE(VB_RECORD, LOC +
     495                QString("Stream on PID 0x%1 is unencrypted").arg(pid,0,16));
     496
     497        GetStreamData()->RemoveEncryptionTestPID(pid);
     498        GetStreamData()->RemoveListeningPID(pid);
     499
     500        AddFlags(kDTVSigMon_CryptMatch);
     501    }
     502}
     503
    435504ATSCStreamData *DTVSignalMonitor::GetATSCStreamData()
    436505{
    437506    return dynamic_cast<ATSCStreamData*>(stream_data);
    … …  
    479548            return false;
    480549    if ((flags & kDTVSigMon_WaitForSDT) && !matchingSDT.IsGood())
    481550            return false;
     551    if ((flags & kDTVSigMon_WaitForCrypt) && !matchingCrypt.IsGood())
     552            return false;
    482553
    483554    return true;
    484555}