Ticket #3031: 3031-dbg-7.patch

File 3031-dbg-7.patch, 19.1 KB (added by danielk, 13 years ago)

Another debugging patch

  • libs/libmythtv/dvbrecorder.cpp

     
    322322
    323323        if (atsc && atsc->DesiredMinorChannel())
    324324            atsc->SetDesiredChannel(atsc->DesiredMajorChannel(),
    325                                     atsc->DesiredMinorChannel());
     325                                    atsc->DesiredMinorChannel(),
     326                                    "dvbrecorder.cpp 326");
    326327        else if (data->DesiredProgram() >= 0)
    327             data->SetDesiredProgram(data->DesiredProgram());
     328            data->SetDesiredProgram(data->DesiredProgram(),
     329                                    "dvbrecorder.cpp 329");
    328330    }
    329331}
    330332
  • libs/libmythtv/hdtvrecorder.cpp

     
    769769                        .arg(vct->ProgramNumber(i)));
    770770                // Do a (partial?) reset here if old desired
    771771                // program is not 0?
    772                 GetATSCStreamData()->SetDesiredProgram(vct->ProgramNumber(i));
     772                GetATSCStreamData()->SetDesiredProgram(
     773                    vct->ProgramNumber(i), "hdtvrecorder.cpp 773");
    773774            }
    774775            found = true;
    775776        }
     
    784785                .arg(vct->MajorChannel(0))
    785786                .arg(vct->MinorChannel(0)));
    786787        VERBOSE(VB_IMPORTANT, vct->toString());
    787         GetATSCStreamData()->SetDesiredProgram(vct->ProgramNumber(0));
     788        GetATSCStreamData()->SetDesiredProgram(
     789            vct->ProgramNumber(0), "hdtvrecorder.cpp 789");
    788790    }
    789791}
    790792
  • libs/libmythtv/hdhrrecorder.cpp

     
    170170
    171171        if (atsc && atsc->DesiredMinorChannel())
    172172            atsc->SetDesiredChannel(atsc->DesiredMajorChannel(),
    173                                     atsc->DesiredMinorChannel());
     173                                    atsc->DesiredMinorChannel(),
     174                                    "hdhrrecorder.cpp 174");
    174175        else if (data->DesiredProgram() >= 0)
    175             data->SetDesiredProgram(data->DesiredProgram());
     176            data->SetDesiredProgram(data->DesiredProgram(),
     177                                    "hdhrrecorder.cpp 177");
    176178    }
    177179}
    178180
  • libs/libmythtv/firewirerecorder.cpp

     
    204204        data->AddMPEGSPListener(this);
    205205
    206206        if (data->DesiredProgram() >= 0)
    207             data->SetDesiredProgram(data->DesiredProgram());
     207            data->SetDesiredProgram(
     208                data->DesiredProgram(), "firewirerecorder.cpp 208");
    208209    }
    209210}
    210211
  • libs/libmythtv/siscan.cpp

     
    743743    // If we have a DTV Signal Monitor, perform table scanner reset
    744744    if (GetDTVSignalMonitor() && GetDTVSignalMonitor()->GetScanStreamData())
    745745    {
    746         GetDTVSignalMonitor()->GetScanStreamData()->Reset();
     746        GetDTVSignalMonitor()->GetScanStreamData()->Reset("siscan.cpp 746");
    747747        GetDTVSignalMonitor()->SetChannel(-1,-1);
    748748    }
    749749
  • libs/libmythtv/mpeg/mpegstreamdata.cpp

     
    7676
    7777MPEGStreamData::~MPEGStreamData()
    7878{
    79     Reset(-1);
     79    Reset(-1, "~MPEGStreamData()");
    8080    SetPATSingleProgram(NULL);
    8181    SetPMTSingleProgram(NULL);
    8282
     
    9090    _mpeg_sp_listeners.clear();
    9191}
    9292
    93 void MPEGStreamData::SetDesiredProgram(int p)
     93void MPEGStreamData::SetDesiredProgram(int p, const QString &where)
    9494{
     95    VERBOSE(VB_IMPORTANT,
     96            QString("MPEGStreamData::SetDesiredProgram(%1) called from %2")
     97            .arg(p).arg(where));
     98
    9599    bool reset = true;
    96100    uint pid = 0;
    97101    const ProgramAssociationTable* pat = NULL;
     
    120124    ReturnCachedPATTables(pats);
    121125
    122126    if (reset)
    123         Reset(p);
     127        Reset(p, QString("MPEGStreamData::SetDesiredProgram(%1)").arg(p));
    124128}
    125129
    126130void MPEGStreamData::SetEITHelper(EITHelper *eit_helper)
     
    135139    _eit_rate = rate;
    136140}
    137141
    138 void MPEGStreamData::Reset(int desiredProgram)
     142void MPEGStreamData::Reset(int desiredProgram, const QString &where)
    139143{
     144    VERBOSE(VB_IMPORTANT,
     145            QString("MPEGStreamData::Reset(%1) called from %2")
     146            .arg(desiredProgram).arg(where));
     147
    140148    _desired_program = desiredProgram;
    141149    _invalid_pat_seen = false;
    142150
     
    500508
    501509    if (TableID::PAT == table_id)
    502510    {
     511        VERBOSE(VB_IMPORTANT, "PAT seen");
    503512        if (VersionPAT(psip.TableIDExtension()) != version)
    504513            return false;
    505514        return PATSectionSeen(psip.TableIDExtension(), psip.Section());
     
    510519
    511520    if (TableID::PMT == table_id)
    512521    {
     522        VERBOSE(VB_IMPORTANT, "PMT seen");
    513523        if (VersionPMT(psip.TableIDExtension()) != version)
    514524            return false;
    515525        return PMTSectionSeen(psip.TableIDExtension(), psip.Section());
  • libs/libmythtv/mpeg/atscstreamdata.cpp

     
    4444
    4545ATSCStreamData::~ATSCStreamData()
    4646{
    47     Reset(-1,-1);
     47    Reset(-1,-1, "~ATSCStreamData");
    4848
    4949    QMutexLocker locker(&_listener_lock);
    5050    _atsc_main_listeners.clear();
     
    5252    _atsc_eit_listeners.clear();
    5353}
    5454
    55 void ATSCStreamData::SetDesiredChannel(int major, int minor)
     55void ATSCStreamData::SetDesiredChannel(
     56    int major, int minor, const QString &where)
    5657{
     58    VERBOSE(VB_IMPORTANT,
     59            QString("ATSCStreamData::SetDesiredChannel(%1,%2) called from %3")
     60            .arg(major).arg(minor).arg(where));
     61
    5762    bool reset = true;
    5863    const MasterGuideTable *mgt = GetCachedMGT();
    5964    tvct_vec_t tvcts = GetAllCachedTVCTs();
     
    8691            if (cvct)
    8792            {
    8893                ProcessCVCT(cvct->TransportStreamID(), cvct);
    89                 SetDesiredProgram(cvct->ProgramNumber(chan_idx));
     94                SetDesiredProgram(
     95                    cvct->ProgramNumber(chan_idx),
     96                    QString("ATSCStreamData::SetDesiredChannel(%1,%2) CVCT")
     97                    .arg(major).arg(minor));
    9098            }
    9199            else if (tvct)
    92100            {
    93101                ProcessTVCT(tvct->TransportStreamID(), tvct);
    94                 SetDesiredProgram(tvct->ProgramNumber(chan_idx));
     102                SetDesiredProgram(
     103                    tvct->ProgramNumber(chan_idx),
     104                    QString("ATSCStreamData::SetDesiredChannel(%1,%2) TVCT")
     105                    .arg(major).arg(minor));
    95106            }
    96107            reset = false;
    97108        }
     
    102113    ReturnCachedCVCTTables(cvcts);
    103114
    104115    if (reset)
    105         Reset(major, minor);
     116    {
     117        Reset(major, minor,
     118              QString("ATSCStreamData::SetDesiredChannel(%1,%2) Reset")
     119              .arg(major).arg(minor));
     120    }
    106121}
    107122
    108 void ATSCStreamData::Reset(int desiredProgram)
     123/*
     124void ATSCStreamData::Reset(int desiredProgram, const QString &where)
    109125{
    110     Reset(-1,-1);
    111     MPEGStreamData::Reset(desiredProgram);
     126    VERBOSE(VB_IMPORTANT,
     127            QString("ATSCStreamData::Reset(int) called from %1").arg(where));
     128
     129    Reset(-1,-1, "ATSCStreamData::Reset(int)");
     130
     131    MPEGStreamData::Reset(desiredProgram, "ATSCStreamData::Reset(int)");
    112132    AddListeningPID(ATSC_PSIP_PID);
    113133}
     134*/
    114135
    115 void ATSCStreamData::Reset(int major, int minor)
     136void ATSCStreamData::Reset(int major, int minor, const QString &where)
    116137{
     138    VERBOSE(VB_IMPORTANT,
     139            QString("ATSCStreamData::Reset(%1,%2) called from %3")
     140            .arg(major).arg(minor).arg(where));
     141
    117142    _desired_major_channel = major;
    118143    _desired_minor_channel = minor;
    119144   
    120     MPEGStreamData::Reset(-1);
     145    MPEGStreamData::Reset(-1, QString("ATSCStreamData::Reset(%1,%2)")
     146                          .arg(major).arg(minor));
     147
    121148    _mgt_version = -1;
    122149    _tvct_version.clear();
    123150    _cvct_version.clear();
  • libs/libmythtv/mpeg/dvbstreamdata.cpp

     
    2727
    2828DVBStreamData::~DVBStreamData()
    2929{
    30     Reset(_desired_netid, _desired_tsid, _desired_program);
     30    Reset(_desired_netid, _desired_tsid, _desired_program, "~DVBStreamData()");
    3131
    3232    QMutexLocker locker(&_listener_lock);
    3333    _dvb_main_listeners.clear();
     
    3636    _dvb_has_eit.clear();
    3737}
    3838
    39 void DVBStreamData::SetDesiredService(uint netid, uint tsid, int serviceid)
     39void DVBStreamData::SetDesiredService(uint netid, uint tsid, int serviceid,
     40                                      const QString &where)
    4041{
     42    VERBOSE(VB_IMPORTANT,
     43            QString("DVBStreamData::SetDesiredSevice(%1,%2,%3) called from %4")
     44            .arg(netid).arg(tsid).arg(serviceid).arg(where));
     45
    4146    bool reset = true;
    4247
    4348    if (HasCachedAllSDT(tsid, true))
     
    5863                ProcessSDT(_desired_tsid, sdt);
    5964                ReturnCachedTable(sdt);
    6065            }
    61             SetDesiredProgram(serviceid);
     66            SetDesiredProgram(
     67                serviceid,
     68                QString("DVBStreamData::SetDesiredSevice(%1,%2,%3)")
     69                .arg(netid).arg(tsid).arg(serviceid));
    6270        }
    6371    }
    6472
    6573    if (reset)
    66         Reset(netid, tsid, serviceid);
     74    {
     75        Reset(netid, tsid, serviceid,
     76              QString("DVBStreamData::SetDesiredService(%1,%2,%3)")
     77              .arg(netid).arg(tsid).arg(serviceid));
     78    }
    6779}
    6880
    6981
     
    165177}
    166178
    167179void DVBStreamData::Reset(uint desired_netid, uint desired_tsid,
    168                           int desired_serviceid)
     180                          int desired_serviceid, const QString &where)
    169181{
    170     MPEGStreamData::Reset(desired_serviceid);
     182    VERBOSE(VB_IMPORTANT,
     183            QString("DVBStreamData::Reset(%1,%2,%3) called from %4")
     184            .arg(desired_netid).arg(desired_tsid)
     185            .arg(desired_serviceid).arg(where));
    171186
     187    MPEGStreamData::Reset(desired_serviceid, "DVBStreamData::Reset()");
     188
    172189    _desired_netid = desired_netid;
    173190    _desired_tsid  = desired_tsid;
    174191
  • libs/libmythtv/mpeg/scanstreamdata.h

     
    1818    bool IsRedundant(uint pid, const PSIPTable&) const;
    1919    bool HandleTables(uint pid, const PSIPTable &psip);
    2020
    21     void Reset(void);
     21    void Reset(const QString &where);
    2222
    2323    bool HasEITPIDChanges(const uint_vec_t& /*in_use_pids*/) const
    2424        { return false; }
  • libs/libmythtv/mpeg/mpegstreamdata.h

     
    7474    virtual ~MPEGStreamData();
    7575
    7676    void SetCaching(bool cacheTables) { _cache_tables = cacheTables; }
    77     virtual void Reset(int desiredProgram);
     77    virtual void Reset(const QString &where)
     78    {
     79        VERBOSE(VB_IMPORTANT,
     80                QString("MPEGStreamData::Reset(void) called from %1")
     81                .arg(where));
    7882
     83        Reset(-1, "MPEGStreamData::Reset(void)");
     84    }
     85    virtual void Reset(int desiredProgram, const QString &where);
     86
    7987    /// \brief Current Offset from computer time to DVB time in seconds
    8088    double TimeOffset(void) const;
    8189
     
    209217
    210218  public:
    211219    // Single program stuff, sets
    212     void SetDesiredProgram(int p);
     220    void SetDesiredProgram(int p, const QString &where);
    213221    inline void SetPATSingleProgram(ProgramAssociationTable*);
    214222    inline void SetPMTSingleProgram(ProgramMapTable*);
    215223    void SetVideoStreamsRequired(uint num)
  • libs/libmythtv/mpeg/atscstreamdata.h

     
    2727                   bool cacheTables = false);
    2828   ~ATSCStreamData();
    2929
    30     void Reset(void) { Reset(-1, -1); }
    31     void Reset(int desiredProgram);
    32     void Reset(int desiredMajorChannel, int desiredMinorChannel);
    33     void SetDesiredChannel(int major, int minor);
     30    void Reset(const QString &where)
     31    {
     32        VERBOSE(VB_IMPORTANT,
     33                QString("ATSCStreamData::Reset(void) called from %1")
     34                .arg(where));
    3435
     36        Reset(-1, -1, "ATSCStreamData::Reset(void)");
     37    }
     38    //void Reset(int desiredProgram, const QString &where);
     39    void Reset(int desiredMajorChannel, int desiredMinorChannel,
     40               const QString &where);
     41    void SetDesiredChannel(int major, int minor, const QString  &where);
     42
    3543    // Table processing
    3644    virtual bool HandleTables(uint pid, const PSIPTable &psip);
    3745    virtual bool IsRedundant(uint, const PSIPTable&) const;
  • libs/libmythtv/mpeg/dvbstreamdata.h

     
    2626                  int desired_program, bool cacheTables = false);
    2727    ~DVBStreamData();
    2828
    29     void Reset(void) { Reset(0, 0, -1); }
    30     void Reset(uint desired_netid, uint desired_tsid, int desired_sid);
     29    void Reset(const QString &where)
     30    {
     31        VERBOSE(VB_IMPORTANT,
     32                QString("DVBStreamData::Reset(void) called from %1")
     33                .arg(where));
    3134
     35        Reset(0, 0, -1, "DVBStreamData::Reset(void)");
     36    }
     37    void Reset(uint desired_netid, uint desired_tsid,
     38               int desired_sid, const QString &where);
     39
    3240    // DVB table monitoring
    33     void SetDesiredService(uint netid, uint tsid, int serviceid);
     41    void SetDesiredService(uint netid, uint tsid, int serviceid,
     42                           const QString &where);
    3443    uint DesiredNetworkID(void)   const { return _desired_netid; }
    3544    uint DesiredTransportID(void) const { return _desired_tsid;  }
    3645
  • libs/libmythtv/mpeg/scanstreamdata.cpp

     
    3232    return h0 || h1;
    3333}
    3434
    35 void ScanStreamData::Reset(void)
     35void ScanStreamData::Reset(const QString &where)
    3636{
    37     MPEGStreamData::Reset(-1);
    38     ATSCStreamData::Reset(-1,-1);
    39     DVBStreamData::Reset(0,0,-1);
     37    VERBOSE(VB_IMPORTANT,
     38            QString("ScanStreamData::Reset(void) called from %1").arg(where));
    4039
     40    MPEGStreamData::Reset(-1, "ScanStreamData::Reset(void)");
     41    ATSCStreamData::Reset(-1,-1, "ScanStreamData::Reset(void)");
     42    DVBStreamData::Reset(0,0,-1, "ScanStreamData::Reset(void)");
     43
    4144    AddListeningPID(MPEG_PAT_PID);
    4245    AddListeningPID(ATSC_PSIP_PID);
    4346    AddListeningPID(DVB_NIT_PID);
  • libs/libmythtv/iptvrecorder.cpp

     
    7575        Open();
    7676
    7777    if (_stream_data)
    78         _stream_data->Reset(_stream_data->DesiredProgram());
     78        _stream_data->Reset(_stream_data->DesiredProgram(), "iptvrecorder.cpp:78");
    7979
    8080    DTVRecorder::Unpause();
    8181
  • libs/libmythtv/tv_rec.cpp

     
    16881688                GetDTVRecorder()->SetStreamData(asd);
    16891689        }
    16901690
    1691         asd->Reset(major, minor);
     1691        asd->Reset("tv_rec.cpp:1691");
     1692        //asd->Reset(major, minor, "tv_rec.cpp:1691");
    16921693        sm->SetStreamData(sd);
    16931694        sm->SetChannel(major, minor);
    16941695        sd->SetVideoStreamsRequired(neededVideo);
     
    17301731        if (GetDVBChannel())
    17311732            sd->SetIgnoreCRC(GetDVBChannel()->HasCRCBug());
    17321733
    1733         dsd->Reset(netid, tsid, progNum);
     1734        dsd->Reset("tv_rec.cpp:1734");
     1735        //dsd->Reset(netid, tsid, progNum);
    17341736        sm->SetStreamData(sd);
    17351737        sm->SetDVBService(netid, tsid, progNum);
    17361738        sd->SetVideoStreamsRequired(neededVideo);
     
    17681770            sd->SetIgnoreCRC(GetDVBChannel()->HasCRCBug());
    17691771#endif // USING_DVB
    17701772
    1771         sd->Reset(progNum);
     1773        //sd->Reset("tv_rec.cpp:1773");
     1774        //sd->Reset(progNum, "tv_rec.cpp:1774");
    17721775        sm->SetStreamData(sd);
    17731776        sm->SetProgramNumber(progNum);
    17741777        sd->SetVideoStreamsRequired(neededVideo);
     
    34113414
    34123415            ATSCStreamData *atsc = dynamic_cast<ATSCStreamData*>(mpeg);
    34133416            if (atsc)
    3414                 atsc->SetDesiredChannel(request.majorChan, request.minorChan);
     3417                atsc->SetDesiredChannel(request.majorChan, request.minorChan,
     3418                                        "tv_rec.cpp 3418");
    34153419        }
    34163420        else if (request.progNum >= 0)
    34173421        {
    34183422            channel->SetChannelByString(request.channel);
    34193423
    34203424            if (mpeg)
    3421                 mpeg->SetDesiredProgram(request.progNum);
     3425                mpeg->SetDesiredProgram(request.progNum, "tv_rec.cpp 3425");
    34223426        }
    34233427    }
    34243428
  • libs/libmythtv/dtvsignalmonitor.cpp

     
    193193                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    194194        majorChannel = major;
    195195        minorChannel = minor;
    196         GetATSCStreamData()->SetDesiredChannel(major, minor);
     196        GetATSCStreamData()->SetDesiredChannel(
     197            major, minor, "DTVSignalMonitor::SetChannel");
    197198        AddFlags(kDTVSigMon_WaitForVCT | kDTVSigMon_WaitForPAT);
    198199    }
    199200}
     
    207208                    kDTVSigMon_CryptSeen | kDTVSigMon_CryptMatch);
    208209        programNumber = progNum;
    209210        if (GetStreamData())
    210             GetStreamData()->SetDesiredProgram(programNumber);
     211            GetStreamData()->SetDesiredProgram(
     212                programNumber, "DTVSignalMonitor::SetProgramNumber");
    211213        AddFlags(kDTVSigMon_WaitForPMT);
    212214    }
    213215}
     
    233235
    234236    if (GetDVBStreamData())
    235237    {
    236         GetDVBStreamData()->SetDesiredService(netid, tsid, programNumber);
     238        GetDVBStreamData()->SetDesiredService(
     239            netid, tsid, programNumber, "DTVSignalMonitor::SetDVBService");
    237240        AddFlags(kDTVSigMon_WaitForPMT | kDTVSigMon_WaitForSDT);
    238241        GetDVBStreamData()->AddListeningPID(DVB_SDT_PID);
    239242    }