Ticket #1783: streamdata_leak_fix.3.diff

File streamdata_leak_fix.3.diff, 22.4 KB (added by Janne <janne-mythtv@…>, 19 years ago)
  • libs/libmythtv/dtvsignalmonitor.cpp

    old new void DTVSignalMonitor::SetDVBService(uin  
    222222
    223223void DTVSignalMonitor::SetStreamData(MPEGStreamData *data)
    224224{
     225    if (stream_data == data)
     226        return;
     227
    225228    if (stream_data)
    226229        stream_data->RemoveMPEGListener(this);
    227230
  • libs/libmythtv/tv_rec.cpp

    old new static QString load_profile(QString,void  
    110110TVRec::TVRec(int capturecardnum)
    111111       // Various components TVRec coordinates
    112112    : recorder(NULL), channel(NULL), signalMonitor(NULL),
    113       scanner(new EITScanner()),
     113      scanner(new EITScanner()), streamData(NULL),
    114114      // Configuration variables from database
    115115      eitIgnoresSource(false),      transcodeFirst(false),
    116116      earlyCommFlag(false),         runJobOnHostOnly(false),
    void TVRec::TeardownAll(void)  
    317317
    318318    TeardownRecorder(true);
    319319
     320    SetMPEGStreamData(NULL);
     321
    320322    SetRingBuffer(NULL);
    321323}
    322324
    QString TVRec::GetStartChannel(int cardi  
    15651567    return startchan;
    15661568}
    15671569
    1568 void GetPidsToCache(DTVSignalMonitor *dtvMon, pid_cache_t &pid_cache)
     1570void GetPidsToCache(ATSCStreamData *asd, pid_cache_t &pid_cache)
    15691571{
    1570     if (!dtvMon->GetATSCStreamData())
     1572    if (!asd)
    15711573        return;
    15721574
    1573     const MasterGuideTable *mgt = dtvMon->GetATSCStreamData()->GetCachedMGT();
     1575    const MasterGuideTable *mgt = asd->GetCachedMGT();
    15741576    if (!mgt)
    15751577        return;
    15761578
    void GetPidsToCache(DTVSignalMonitor *dt  
    15791581        pid_cache_item_t item(mgt->TablePID(i), mgt->TableType(i));
    15801582        pid_cache.push_back(item);
    15811583    }
    1582     dtvMon->GetATSCStreamData()->ReturnCachedTable(mgt);
     1584    asd->ReturnCachedTable(mgt);
    15831585}
    15841586
    1585 bool ApplyCachedPids(DTVSignalMonitor *dtvMon, const ChannelBase* channel)
     1587bool ApplyCachedPids(ATSCStreamData *asd, const ChannelBase* channel)
    15861588{
    15871589    pid_cache_t pid_cache;
    15881590    channel->GetCachedPids(pid_cache);
    bool ApplyCachedPids(DTVSignalMonitor *d  
    15941596            (it->second == TableID::CVCT))
    15951597        {
    15961598            vctpid_cached = true;
    1597             dtvMon->GetATSCStreamData()->AddListeningPID(it->first);
     1599            asd->AddListeningPID(it->first);
    15981600        }
    15991601    }
    16001602    return vctpid_cached;
    bool TVRec::SetupDTVSignalMonitor(void)  
    16171619    VERBOSE(VB_RECORD, LOC + "Setting up table monitoring.");
    16181620
    16191621    DTVSignalMonitor *sm = GetDTVSignalMonitor();
    1620     MPEGStreamData *sd = NULL;
    1621     if (GetDTVRecorder())
    1622     {
    1623         sd = GetDTVRecorder()->GetStreamData();
     1622    MPEGStreamData *sd = GetMPEGStreamData();
     1623    if (sd)
    16241624        sd->SetCaching(true);
    1625     }
    16261625
    16271626    // Check if this is an ATSC Channel
    16281627    int major = channel->GetMajorChannel();
    bool TVRec::SetupDTVSignalMonitor(void)  
    16361635        if (!asd)
    16371636        {
    16381637            sd = asd = new ATSCStreamData(major, minor);
     1638            SetMPEGStreamData(asd);
    16391639            sd->SetCaching(true);
    16401640            if (GetDTVRecorder())
    16411641                GetDTVRecorder()->SetStreamData(asd);
    bool TVRec::SetupDTVSignalMonitor(void)  
    16481648
    16491649        // Try to get pid of VCT from cache and
    16501650        // require MGT if we don't have VCT pid.
    1651         if (!ApplyCachedPids(sm, channel))
     1651        if (!ApplyCachedPids(GetATSCStreamData(), channel))
    16521652            sm->AddFlags(kDTVSigMon_WaitForMGT);
    16531653
    16541654        VERBOSE(VB_RECORD, LOC + "Successfully set up ATSC table monitoring.");
    bool TVRec::SetupDTVSignalMonitor(void)  
    16691669        if (!dsd)
    16701670        {
    16711671            sd = dsd = new DVBStreamData(netid, tsid, progNum);
     1672            SetMPEGStreamData(dsd);
    16721673            sd->SetCaching(true);
    16731674            if (GetDTVRecorder())
    16741675                GetDTVRecorder()->SetStreamData(dsd);
    bool TVRec::SetupDTVSignalMonitor(void)  
    17161717        if (!sd)
    17171718        {
    17181719            sd = new MPEGStreamData(progNum, true);
     1720            SetMPEGStreamData(sd);
    17191721            sd->SetCaching(true);
    17201722            if (GetDTVRecorder())
    17211723                GetDTVRecorder()->SetStreamData(sd);
    void TVRec::TeardownSignalMonitor()  
    18141816    if (dtvMon && channel)
    18151817    {
    18161818        pid_cache_t pid_cache;
    1817         GetPidsToCache(dtvMon, pid_cache);
     1819        GetPidsToCache(GetATSCStreamData(), pid_cache);
    18181820        if (pid_cache.size())
    18191821            channel->SaveCachedPids(pid_cache);
    18201822    }
    bool TVRec::TuningOnSameMultiplex(Tuning  
    30603062
    30613063    if (ChannelUtil::IsOnSameMultiplex(sourceid, newchannum, oldchannum))
    30623064    {
    3063         MPEGStreamData *mpeg = GetDTVRecorder()->GetStreamData();
     3065        MPEGStreamData *mpeg = GetMPEGStreamData();
    30643066        ATSCStreamData *atsc = dynamic_cast<ATSCStreamData*>(mpeg);
    30653067
    30663068        if (atsc)
    void TVRec::HandleTuning(void)  
    31643166        TuningFrequency(lastTuningRequest);
    31653167    }
    31663168
    3167     MPEGStreamData *streamData = NULL;
    3168     bool handle_done = (HasFlags(kFlagWaitingForSignal) &&
    3169                         !(streamData = TuningSignalCheck()));
     3169    MPEGStreamData *streamData = GetMPEGStreamData();
     3170    bool handle_done = (HasFlags(kFlagWaitingForSignal) && !TuningSignalCheck());
    31703171
    31713172    // Just because we have signal, we may not have the right transponder.
    31723173    if (HasFlags(kFlagWaitingForSignal) && !retune_timer->elapsed() &&
    void TVRec::TuningFrequency(const Tuning  
    33443345{
    33453346    if (request.minorChan)
    33463347    {
    3347         MPEGStreamData *mpeg = GetDTVRecorder()->GetStreamData();
     3348        MPEGStreamData *mpeg = GetMPEGStreamData();
    33483349        ATSCStreamData *atsc = dynamic_cast<ATSCStreamData*>(mpeg);
    33493350        channel->SetChannelByString(request.channel);
    33503351        atsc->SetDesiredChannel(request.majorChan, request.minorChan);
    33513352    }
    33523353    else if (request.progNum >= 0)
    33533354    {
    3354         MPEGStreamData *mpeg = GetDTVRecorder()->GetStreamData();
     3355        MPEGStreamData *mpeg = GetMPEGStreamData();
    33553356        channel->SetChannelByString(request.channel);
    33563357        mpeg->SetDesiredProgram(request.progNum);
    33573358    }
    void TVRec::TuningFrequency(const Tuning  
    34463447        {
    34473448            if (request.flags & kFlagEITScan)
    34483449            {
    3449                 GetDTVSignalMonitor()->GetStreamData()->
    3450                     SetVideoStreamsRequired(0);
     3450                GetMPEGStreamData()->SetVideoStreamsRequired(0);
    34513451            }
    34523452
    34533453            SetFlags(kFlagSignalMonitorRunning);
    void TVRec::TuningFrequency(const Tuning  
    34773477 *
    34783478 *  \return MPEGStreamData pointer if we have a complete lock, NULL otherwise
    34793479 */
    3480 MPEGStreamData *TVRec::TuningSignalCheck(void)
     3480bool TVRec::TuningSignalCheck(void)
    34813481{
    34823482    if (!signalMonitor->IsAllGood())
    34833483        return NULL;
    34843484
    34853485    VERBOSE(VB_RECORD, LOC + "Got good signal");
    34863486
    3487     // grab useful data from DTV signal monitor before we kill it...
    3488     MPEGStreamData *streamData = NULL;
    3489     if (GetDTVSignalMonitor())
    3490         streamData = GetDTVSignalMonitor()->GetStreamData();
     3487    MPEGStreamData *streamData = GetMPEGStreamData();
    34913488
    34923489    if (!HasFlags(kFlagEITScannerRunning))
    34933490    {
    MPEGStreamData *TVRec::TuningSignalCheck  
    35053502        scanner->StartPassiveScan(channel, streamData, eitIgnoresSource);
    35063503    }
    35073504
    3508     return streamData;
     3505    return true;
    35093506}
    35103507
    35113508static int init_jobs(const ProgramInfo *rec, RecordingProfile &profile,
    QString TuningRequest::toString(void) co  
    40404037        .arg((program != 0) ? "yes" : "no").arg(channel).arg(input)
    40414038        .arg(TVRec::FlagToString(flags));
    40424039}
     4040
     4041
     4042void TVRec::SetMPEGStreamData(MPEGStreamData *sd)
     4043{
     4044    if (streamData == sd)
     4045        return;
     4046
     4047    if (streamData)
     4048    {
     4049        VERBOSE(VB_IMPORTANT, LOC + "Deleting streamData");
     4050        delete streamData;
     4051    }
     4052
     4053    streamData = sd;
     4054}
     4055
     4056MPEGStreamData *TVRec::GetMPEGStreamData(void)
     4057{
     4058    return streamData;
     4059}
     4060
     4061ATSCStreamData *TVRec::GetATSCStreamData(void)
     4062{
     4063    return dynamic_cast<ATSCStreamData*>(streamData);
     4064}
     4065
     4066DVBStreamData  *TVRec::GetDVBStreamData(void)
     4067{
     4068    return dynamic_cast<DVBStreamData*>(streamData);
     4069}
  • libs/libmythtv/tv_rec.h

    old new class DVBChannel;  
    4040class Channel;
    4141
    4242class MPEGStreamData;
     43class ATSCStreamData;
     44class DVBStreamData;
    4345class ProgramMapTable;
    4446
    4547/// Used to request ProgramInfo for channel browsing.
    class TVRec : public QObject  
    290292    void TeardownSignalMonitor(void);
    291293    DTVSignalMonitor *GetDTVSignalMonitor(void);
    292294
     295    void SetMPEGStreamData(MPEGStreamData *sd);
     296    MPEGStreamData *GetMPEGStreamData(void);
     297    ATSCStreamData *GetATSCStreamData(void);
     298    DVBStreamData  *GetDVBStreamData(void);
     299
    293300    bool HasFlags(uint f) const { return (stateFlags & f) == f; }
    294301    void SetFlags(uint f);
    295302    void ClearFlags(uint f);
    class TVRec : public QObject  
    298305    void HandleTuning(void);
    299306    void TuningShutdowns(const TuningRequest&);
    300307    void TuningFrequency(const TuningRequest&);
    301     MPEGStreamData *TuningSignalCheck(void);
     308    bool TuningSignalCheck(void);
    302309
    303310    void TuningNewRecorder(MPEGStreamData*);
    304311    void TuningRestartRecorder(void);
    class TVRec : public QObject  
    333340    ChannelBase      *channel;
    334341    SignalMonitor    *signalMonitor;
    335342    EITScanner       *scanner;
     343    MPEGStreamData   *streamData;
    336344
    337345    // Various threads
    338346    /// Event processing thread, runs RunTV().
  • libs/libmythtv/dtvsignalmonitor.h

    old new class DTVSignalMonitor : public SignalMo  
    5555    /// and connects the table signals to the monitor.
    5656    void SetStreamData(MPEGStreamData* data);
    5757
     58  protected:
    5859    /// Returns the MPEG stream data if it exists
    5960    MPEGStreamData *GetStreamData()      { return stream_data; }
    6061    /// Returns the ATSC stream data if it exists
    class DTVSignalMonitor : public SignalMo  
    7374    /// Returns the scan stream data if it exists
    7475    const ScanStreamData *GetScanStreamData() const;
    7576
     77  public:
    7678    bool IsAllGood(void) const;
    7779
    7880    bool WaitForLock(int timeout=-1);
  • libs/libmythtv/dtvrecorder.h

    old new class DTVRecorder: public RecorderBase  
    4040
    4141    virtual void SetNextRecording(const ProgramInfo*, RingBuffer*);
    4242    virtual void SetStreamData(MPEGStreamData*) {}
    43     virtual MPEGStreamData *GetStreamData(void) { return NULL; }
    4443
    4544    virtual void Reset();
    4645
    4746  protected:
     47    virtual MPEGStreamData *GetStreamData(void) { return NULL; }
     48
    4849    void FinishRecording(void);
    4950    void ResetForNewFile(void);
    5051
  • libs/libmythtv/dvbrecorder.h

    old new class DVBRecorder : public DTVRecorder,  
    8080    void HandlePMT(uint pid, const ProgramMapTable*);
    8181
    8282    void SetStreamData(MPEGStreamData*);
    83     MPEGStreamData* GetStreamData(void) { return _stream_data; }
    8483
    8584  private:
     85    MPEGStreamData* GetStreamData(void) { return _stream_data; }
     86
    8687    void TeardownAll(void);
    8788
    8889    uint ProcessDataTS(unsigned char *buffer, uint len);
  • libs/libmythtv/hdhrrecorder.h

    old new class HDHRRecorder : public DTVRecorder,  
    3636    void StartRecording(void);
    3737
    3838    void SetStreamData(MPEGStreamData*);
    39     MPEGStreamData *GetStreamData(void);
    40     ATSCStreamData *GetATSCStreamData(void) { return _atsc_stream_data; }
    4139
    4240    // MPEG Single Program
    4341    void HandleSingleProgramPAT(ProgramAssociationTable *pat);
    class HDHRRecorder : public DTVRecorder,  
    4947    void HandleVCT(uint, const VirtualChannelTable*) {}
    5048
    5149  private:
     50    MPEGStreamData *GetStreamData(void);
     51    ATSCStreamData *GetATSCStreamData(void) { return _atsc_stream_data; }
     52
    5253    void AdjustEITPIDs(void);
    5354    void ProcessTSData(const unsigned char *buffer, int len);
    5455    bool ProcessTSPacket(const TSPacket& tspacket);
  • libs/libmythtv/hdtvrecorder.h

    old new class HDTVRecorder : public DTVRecorder,  
    5353    bool Open(void);
    5454
    5555    void SetStreamData(MPEGStreamData*);
    56     MPEGStreamData* GetStreamData(void);
    57     ATSCStreamData* GetATSCStreamData(void) { return _atsc_stream_data; }
    5856
    5957    void HandleSingleProgramPAT(ProgramAssociationTable*);
    6058    void HandleSingleProgramPMT(ProgramMapTable*);
    class HDTVRecorder : public DTVRecorder,  
    6462    void HandleVCT(uint, const VirtualChannelTable*);
    6563
    6664  private:
     65    MPEGStreamData* GetStreamData(void);
     66    ATSCStreamData* GetATSCStreamData(void) { return _atsc_stream_data; }
     67
    6768    void TeardownAll(void);
    6869
    6970    int  ProcessData    (const unsigned char *buffer, uint len);
  • libs/libmythtv/dvbrecorder.cpp

    old new void DVBRecorder::TeardownAll(void)  
    151151        delete _input_pmt;
    152152        _input_pmt = NULL;
    153153    }
     154
     155    SetStreamData(NULL);
    154156}
    155157
    156158void DVBRecorder::SetOption(const QString &name, int value)
    void DVBRecorder::SetStreamData(MPEGStre  
    274276    if (data == _stream_data)
    275277        return;
    276278
    277     MPEGStreamData *old_data = _stream_data;
     279    if (_stream_data)
     280    {
     281        _stream_data->RemoveMPEGListener(this);
     282    }
     283
    278284    _stream_data = data;
    279     if (old_data)
    280         delete old_data;
    281285
    282286    if (data)
    283287    {
  • libs/libmythtv/hdhrrecorder.cpp

    old new void HDHRRecorder::TeardownAll(void)  
    4949{
    5050    StopRecording();
    5151    Close();
    52     if (_atsc_stream_data)
    53     {
    54         delete _atsc_stream_data;
    55         _atsc_stream_data = NULL;
    56     }
     52
     53    SetStreamData(NULL);
     54
    5755}
    5856
    5957void HDHRRecorder::SetOptionsFromProfile(RecordingProfile *profile,
    void HDHRRecorder::SetStreamData(MPEGStr  
    144142    if (data == _atsc_stream_data)
    145143        return;
    146144
    147     ATSCStreamData *old_data = _atsc_stream_data;
     145    if (_atsc_stream_data)
     146    {
     147        _atsc_stream_data->RemoveMPEGSPListener(this);
     148        _atsc_stream_data->RemoveATSCMainListener(this);
     149    }
     150
    148151    _atsc_stream_data = data;
    149     if (old_data)
    150         delete old_data;
    151152
    152153    if (data)
    153154    {
  • libs/libmythtv/hdtvrecorder.cpp

    old new HDTVRecorder::HDTVRecorder(TVRec *rec)  
    114114      _atsc_stream_data(NULL),
    115115      _resync_count(0)
    116116{
    117     SetStreamData(new ATSCStreamData(-1, DEFAULT_SUBCHANNEL));
     117    // XXX: Is this necessary?
     118    // If yes how should we handle it when TVRec owns the StreamData
     119    //SetStreamData(new ATSCStreamData(-1, DEFAULT_SUBCHANNEL));
    118120
    119121    _buffer_size = TSPacket::SIZE * 1500;
    120122    if ((_buffer = new unsigned char[_buffer_size])) {
    void HDTVRecorder::SetStreamData(MPEGStr  
    210212    if (data == _atsc_stream_data)
    211213        return;
    212214
    213     ATSCStreamData *old_data = _atsc_stream_data;
     215    if (_atsc_stream_data)
     216    {
     217        _atsc_stream_data->RemoveMPEGSPListener(this);
     218        _atsc_stream_data->RemoveATSCMainListener(this);
     219    }
     220
    214221    _atsc_stream_data = data;
    215     if (old_data)
    216         delete old_data;
    217222
    218223    if (data)
    219224    {
  • libs/libmythtv/siscan.cpp

    old new SIScan::SIScan(QString _cardtype, Channe  
    9898    : // Set in constructor
    9999      channel(_channel),
    100100      signalMonitor(SignalMonitor::Init(_cardtype, -1, _channel)),
     101      scanStreamData(new ScanStreamData()),
    101102      sourceID(_sourceID),
    102103      scanMode(IDLE),
    103104      signalTimeout(signal_timeout),
    SIScan::SIScan(QString _cardtype, Channe  
    121122    init_freq_tables();
    122123    current = scanTransports.end();
    123124
    124     // Create a stream data for digital signal monitors
     125    // Setup a stream data for digital signal monitors
    125126    DTVSignalMonitor* dtvSigMon = GetDTVSignalMonitor();
    126127    if (dtvSigMon)
    127128    {
    128129        VERBOSE(VB_SIPARSER, LOC + "Connecting up DTVSignalMonitor");
    129         ScanStreamData *data = new ScanStreamData();
    130130
    131         dtvSigMon->SetStreamData(data);
     131        dtvSigMon->SetStreamData(GetScanStreamData());
    132132        dtvSigMon->AddFlags(kDTVSigMon_WaitForMGT | kDTVSigMon_WaitForVCT |
    133133                            kDTVSigMon_WaitForNIT | kDTVSigMon_WaitForSDT);
    134134
    135         data->AddMPEGListener(this);
    136         data->AddATSCMainListener(this);
    137         data->AddDVBMainListener(this);
     135        GetScanStreamData()->AddMPEGListener(this);
     136        GetScanStreamData()->AddATSCMainListener(this);
     137        GetScanStreamData()->AddDVBMainListener(this);
    138138    }
    139139}
    140140
    SIScan::~SIScan(void)  
    144144    VERBOSE(VB_SIPARSER, LOC + "SIScanner Stopped");
    145145    if (signalMonitor)
    146146        delete signalMonitor;
     147
     148    GetScanStreamData()->RemoveMPEGListener(this);
    147149}
    148150
    149151/** \fn SIScan::ScanServicesSourceID(int)
    void SIScan::HandlePAT(const ProgramAsso  
    221223            .arg((*current).FriendlyName));
    222224
    223225    // Add pmts to list, so we can do MPEG scan properly.
    224     ScanStreamData *sd = GetDTVSignalMonitor()->GetScanStreamData();
     226    ScanStreamData *sd = GetScanStreamData();
    225227    for (uint i = 0; i < pat->ProgramCount(); i++)
    226228    {
    227229        if (pat->ProgramPID(i)) // don't add NIT "program", MPEG/ATSC safe.
    void SIScan::HandleVCT(uint, const Virtu  
    234236    VERBOSE(VB_SIPARSER, LOC + QString("Got a Virtual Channel Table for %1")
    235237            .arg((*current).FriendlyName));
    236238
    237     HandleATSCDBInsertion(GetDTVSignalMonitor()->GetScanStreamData(), true);
     239    HandleATSCDBInsertion(GetScanStreamData(), true);
    238240}
    239241
    240242void SIScan::HandleMGT(const MasterGuideTable*)
    void SIScan::HandleMGT(const MasterGuide  
    242244    VERBOSE(VB_SIPARSER, LOC + QString("Got the Master Guide for %1")
    243245            .arg((*current).FriendlyName));
    244246
    245     HandleATSCDBInsertion(GetDTVSignalMonitor()->GetScanStreamData(), true);
     247    HandleATSCDBInsertion(GetScanStreamData(), true);
    246248}
    247249
    248250void SIScan::HandleSDT(uint, const ServiceDescriptionTable* sdt)
    void SIScan::HandleSDT(uint, const Servi  
    252254            .arg((*current).FriendlyName));
    253255    VERBOSE(VB_SIPARSER, LOC + sdt->toString());
    254256
    255     HandleDVBDBInsertion(GetDTVSignalMonitor()->GetScanStreamData(), true);
     257    HandleDVBDBInsertion(GetScanStreamData(), true);
    256258}
    257259
    258260void SIScan::HandleNIT(const NetworkInformationTable *nit)
    void SIScan::HandleNIT(const NetworkInfo  
    296298        }
    297299    }
    298300
    299     const ScanStreamData *sd = GetDTVSignalMonitor()->GetScanStreamData();
     301    const ScanStreamData *sd = GetScanStreamData();
    300302    const DVBStreamData &dsd = *sd;
    301303    if (dsd.HasAllNITSections())
    302304    {
    void SIScan::HandleNIT(const NetworkInfo  
    304306        emit TransportScanComplete();
    305307    }
    306308
    307     HandleDVBDBInsertion(GetDTVSignalMonitor()->GetScanStreamData(), true);
     309    HandleDVBDBInsertion(GetScanStreamData(), true);
    308310}
    309311
    310312void SIScan::HandleMPEGDBInsertion(const ScanStreamData *sd, bool)
    bool SIScan::HandlePostInsertion(void)  
    414416    if (!dtvSigMon)
    415417        return false;
    416418
    417     const ScanStreamData *sd = dtvSigMon->GetScanStreamData();
     419    const ScanStreamData *sd = GetScanStreamData();
    418420
    419421    VERBOSE(VB_SIPARSER, LOC + "HandlePostInsertion() " +
    420422            QString("pat(%1)").arg(sd->HasCachedAnyPAT()));
    void SIScan::ScanTransport(const transpo  
    697699    }
    698700
    699701    // If we have a DTV Signal Monitor, perform table scanner reset
    700     if (GetDTVSignalMonitor() && GetDTVSignalMonitor()->GetScanStreamData())
     702    if (GetDTVSignalMonitor() && GetScanStreamData())
    701703    {
    702         GetDTVSignalMonitor()->GetScanStreamData()->Reset();
     704        GetScanStreamData()->Reset();
    703705        GetDTVSignalMonitor()->SetChannel(-1,-1);
    704706    }
    705707
  • libs/libmythtv/siscan.h

    old new class SIScan : public QObject,  
    145145
    146146    static QString loc(const SIScan*);
    147147
     148    ScanStreamData *GetScanStreamData(void) { return scanStreamData; }
     149
    148150  private:
    149151    // Set in constructor
    150152    ChannelBase      *channel;
    151153    SignalMonitor    *signalMonitor;
     154    ScanStreamData   *scanStreamData;
    152155    int               sourceID;
    153156    SCANMODE          scanMode;
    154157    uint              signalTimeout;
  • libs/libmythtv/firewirerecorderbase.cpp

    old new const int FirewireRecorderBase::kTimeout  
    1919FirewireRecorderBase::FirewireRecorderBase(TVRec *rec)
    2020    : DTVRecorder(rec), _mpeg_stream_data(NULL)
    2121{
    22     SetStreamData(new MPEGStreamData(1, true));
     22    // XXX: Is this necessary?
     23    // If yes how should we handle it when TVRec owns the StreamData
     24    //SetStreamData(new MPEGStreamData(1, true));
    2325}
    2426
    2527FirewireRecorderBase::~FirewireRecorderBase()
    void FirewireRecorderBase::SetStreamData  
    131133    if (data == _mpeg_stream_data)
    132134        return;
    133135
    134     MPEGStreamData *old_data = _mpeg_stream_data;
     136    if (_mpeg_stream_data)
     137        _mpeg_stream_data->RemoveMPEGSPListener(this);
     138
    135139    _mpeg_stream_data = data;
    136140
    137141    if (data)
    138142        data->AddMPEGSPListener(this);
    139 
    140     if (old_data)
    141         delete old_data;
    142143}
    143144
    144145void FirewireRecorderBase::HandleSingleProgramPAT(