Ticket #5061: multiple-dvb-frontends-trunk.patch

File multiple-dvb-frontends-trunk.patch, 28.8 KB (added by Paul Kendall <paul@…>, 16 years ago)

Patch for multiple DVB frontends for trunk

  • libs/libmythtv/dvbrecorder.cpp

     
    9494
    9595DVBRecorder::DVBRecorder(TVRec *rec, DVBChannel* advbchannel)
    9696    : DTVRecorder(rec),
    97       // Options set in SetOption()
    98       _card_number_option(0),
    9997      // DVB stuff
    10098      dvbchannel(advbchannel),
    10199      _stream_handler(NULL),
    … …  
    145143    }
    146144}
    147145
    148 void DVBRecorder::SetOption(const QString &name, int value)
     146void DVBRecorder::SetOption(const QString &name, const QString &value)
    149147{
    150148    if (name == "cardnum")
    151149    {
    152150        _card_number_option = value;
    153         videodevice = QString::number(value);
     151        videodevice = value;
    154152    }
    155153    else
    156154        DTVRecorder::SetOption(name, value);
    … …  
    160158                                        const QString &videodev,
    161159                                        const QString&, const QString&)
    162160{
    163     SetOption("cardnum", videodev.toInt());
     161    SetOption("cardnum", videodev);
    164162    DTVRecorder::SetOption("tvformat", gContext->GetSetting("TVFormat"));
    165163    SetStrOption(profile,  "recordingtype");
    166164}
    … …  
    318316        return true;
    319317    }
    320318
    321     if (_card_number_option < 0)
     319    if (_card_number_option.isEmpty())
    322320        return false;
    323321
    324322    bzero(_stream_id,  sizeof(_stream_id));

  • libs/libmythtv/cardutil.h

     
    221221    static bool         IsDVB(uint cardid)
    222222        { return "DVB" == GetRawCardType(cardid); }
    223223    static bool         IsDVBCardType(const QString card_type);
    224     static QString      ProbeDVBFrontendName(uint device);
    225     static QString      ProbeDVBType(uint device);
    226     static bool         HasDVBCRCBug(uint device);
    227     static uint         GetMinSignalMonitoringDelay(uint device);
    228     static QString      GetDeviceName(dvb_dev_type_t, uint cardnum);
     224    static QString      ProbeDVBFrontendName(const QString &device);
     225    static QString      ProbeDVBType(const QString &device);
     226    static bool         HasDVBCRCBug(const QString &device);
     227    static uint         GetMinSignalMonitoringDelay(const QString &device);
     228    static QString      GetDeviceName(dvb_dev_type_t, const QString &device);
    229229    static InputNames   GetConfiguredDVBInputs(uint cardid);
    230230
    231231    // V4L info

  • libs/libmythtv/dvbrecorder.h

     
    4949    DVBRecorder(TVRec *rec, DVBChannel* dvbchannel);
    5050   ~DVBRecorder();
    5151
    52     void SetOption(const QString &name, int value);
     52    void SetOption(const QString &name, const QString &value);
    5353
    5454    void SetOptionsFromProfile(RecordingProfile *profile,
    5555                               const QString &videodev,
    … …  
    108108
    109109  private:
    110110    // Options set in SetOption()
    111     int             _card_number_option;
     111    QString          _card_number_option;
    112112
    113113    // DVB stuff
    114114    DVBChannel       *dvbchannel;

  • libs/libmythtv/scanwizardscanner.cpp

     
    402402
    403403            ok = !device.isEmpty();
    404404            if (ok)
    405                 sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
     405                sub_type = CardUtil::ProbeDVBType(device).upper();
    406406        }
    407407
    408408        if (ok)
    … …  
    488488
    489489    if ("DVB" == card_type)
    490490    {
    491         QString sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
     491        QString sub_type = CardUtil::ProbeDVBType(device).upper();
    492492        bool need_nit = (("QAM"  == sub_type) ||
    493493                         ("QPSK" == sub_type) ||
    494494                         ("OFDM" == sub_type));
    … …  
    508508
    509509#ifdef USING_DVB
    510510    if ("DVB" == card_type)
    511         channel = new DVBChannel(device.toInt());
     511        channel = new DVBChannel(device);
    512512#endif
    513513
    514514#ifdef USING_V4L

  • libs/libmythtv/dvbstreamhandler.h

     
    3434        _pid(pid),                       filter_fd(-1),
    3535        streamType(stream_type),         pesType(pes_type) {;}
    3636
    37     bool Open(uint dvb_dev_num, bool use_section_reader);
    38     bool Close(uint dvb_dev_num);
     37    bool Open(const QString &dvb_dev, bool use_section_reader);
     38    bool Close(const QString &dvb_dev);
    3939    bool IsOpen(void) const { return filter_fd >= 0; }
    4040
    4141    uint        _pid;
    … …  
    5050    friend void *run_dvb_stream_handler_thunk(void *param);
    5151
    5252  public:
    53     static DVBStreamHandler *Get(uint dvb_device_number);
     53    static DVBStreamHandler *Get(const QString &dvb_device);
    5454    static void Return(DVBStreamHandler * & ref);
    5555
    5656    void AddListener(MPEGStreamData *data,
    … …  
    7171    virtual void ReaderPaused(int fd) { (void) fd; }
    7272
    7373  private:
    74     DVBStreamHandler(uint);
     74    DVBStreamHandler(const QString &);
    7575    ~DVBStreamHandler();
    7676
    7777    void Start(void);
    … …  
    9494    bool SupportsTSMonitoring(void);
    9595
    9696  private:
    97     uint              _dvb_dev_num;
     97    QString           _dvb_dev;
    9898    QString           _dvr_dev_path;
    9999    bool              _allow_section_reader;
    100100    bool              _needs_buffering;
    … …  
    119119    vector<MPEGStreamData*> _stream_data_list;
    120120
    121121    // for caching TS monitoring supported value.
    122     static QMutex          _rec_supports_ts_monitoring_lock;
    123     static QMap<uint,bool> _rec_supports_ts_monitoring;
     122    static QMutex             _rec_supports_ts_monitoring_lock;
     123    static QMap<QString,bool> _rec_supports_ts_monitoring;
    124124
    125125    // for implementing Get & Return
    126     static QMutex                       _handlers_lock;
    127     static QMap<uint,DVBStreamHandler*> _handlers;
    128     static QMap<uint,uint>              _handlers_refcnt;
     126    static QMutex                          _handlers_lock;
     127    static QMap<QString,DVBStreamHandler*> _handlers;
     128    static QMap<QString,uint>              _handlers_refcnt;
    129129};
    130130
    131131#endif // _DVBSTREAMHANDLER_H_

  • libs/libmythtv/dvbchannel.h

     
    2828class DVBChannel : public DTVChannel
    2929{
    3030  public:
    31     DVBChannel(int cardnum, TVRec *parent = NULL);
     31    DVBChannel(const QString &device, TVRec *parent = NULL);
    3232    ~DVBChannel();
    3333
    3434    bool Open(void) { return Open(this); }
    … …  
    4747    int  GetFd(void)                    const { return fd_frontend; }
    4848    bool IsTuningParamsProbeSupported(void) const;
    4949
    50     QString GetDevice(void) const { return QString::number(GetCardNum()); }
     50    QString GetDevice(void)             const { return device; }
    5151    /// Returns DVB device number, used to construct filenames for DVB devices
    52     int     GetCardNum(void)            const { return cardnum; };
     52    QString GetCardNum(void)            const { return device; };
    5353    /// Returns frontend name as reported by driver
    5454    QString GetFrontendName(void)       const;
    5555    DTVTunerType GetCardType(void)      const { return card_type; }
    … …  
    139139
    140140    // Other State
    141141    int               fd_frontend; ///< File descriptor for tuning hardware
    142     int               cardnum;     ///< DVB Card number
     142    QString           device;      ///< DVB Device
    143143    bool              has_crc_bug; ///< true iff our driver munges PMT
    144144    int               nextInputID; ///< Signal an input change
    145145};

  • libs/libmythtv/dvbcam.h

     
    1717class DVBCam
    1818{
    1919  public:
    20     DVBCam(int cardnum);
     20    DVBCam(const QString &device);
    2121    ~DVBCam();
    2222
    2323    bool Start();
    … …  
    3434
    3535    void SendPMT(const ProgramMapTable &pmt, uint cplm);
    3636
    37     int             cardnum;
     37    QString         device;
    3838    int             numslots;
    3939    cCiHandler     *ciHandler;
    4040

  • libs/libmythtv/dvbchannel.cpp

     
    5555static DTVMultiplex dvbparams_to_dtvmultiplex(
    5656    DTVTunerType, const dvb_fe_params&);
    5757
    58 #define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(cardnum)
     58#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device)
    5959#define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \
    60                  .arg(GetCardID()).arg(cardnum)
    61 #define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(cardnum)
     60                 .arg(GetCardID()).arg(device)
     61#define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(device)
    6262
    6363/** \class DVBChannel
    6464 *  \brief Provides interface to the tuning hardware when using DVB drivers
    6565 *
    6666 *  \bug Only supports single input cards.
    6767 */
    68 DVBChannel::DVBChannel(int aCardNum, TVRec *parent)
     68DVBChannel::DVBChannel(const QString &aDevice, TVRec *parent)
    6969    : DTVChannel(parent),           master(NULL),
    7070      // Helper classes
    7171      diseqc_tree(NULL),            dvbcam(NULL),
    … …  
    7777      tuning_delay(0),              sigmon_delay(25),
    7878      first_tune(true),
    7979      // Misc
    80       fd_frontend(-1),              cardnum(aCardNum),
     80      fd_frontend(-1),              device(aDevice),
    8181      has_crc_bug(false)
    8282{
    83     QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, cardnum);
     83    QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, device);
    8484    master = dynamic_cast<DVBChannel*>(GetMaster(devname));
    8585    master = (master == this) ? NULL : master;
    8686
    8787    if (!master)
    8888    {
    89         dvbcam = new DVBCam(cardnum);
    90         has_crc_bug = CardUtil::HasDVBCRCBug(aCardNum);
     89        dvbcam = new DVBCam(device);
     90        has_crc_bug = CardUtil::HasDVBCRCBug(device);
    9191    }
    9292    else
    9393    {
    … …  
    9595        has_crc_bug  = master->has_crc_bug;
    9696    }
    9797
    98     sigmon_delay = CardUtil::GetMinSignalMonitoringDelay(aCardNum);
     98    sigmon_delay = CardUtil::GetMinSignalMonitoringDelay(device);
    9999}
    100100
    101101DVBChannel::~DVBChannel()
    … …  
    187187        return true;
    188188    }
    189189
    190     QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, cardnum);
     190    QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, device);
    191191    fd_frontend = open(devname.ascii(), O_RDWR | O_NONBLOCK);
    192192
    193193    if (fd_frontend < 0)
    … …  
    262262    symbol_rate_maximum = info.symbol_rate_max;
    263263
    264264    VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.")
    265             .arg(cardnum).arg(frontend_name));
     265            .arg(device).arg(frontend_name));
    266266
    267267    // Turn on the power to the LNB
    268268    if (card_type == DTVTunerType::kTunerTypeQPSK ||

  • libs/libmythtv/cardutil.cpp

     
    168168
    169169    if (rawtype.upper() == "DVB")
    170170    {
    171         QDir dir("/dev/dvb", "adapter*", QDir::Name, QDir::All);
     171        QDir dir("/dev/dvb", "adapter*", QDir::Name, QDir::Dirs);
    172172        const QFileInfoList il = dir.entryInfoList();
    173173        if (il.isEmpty())
    174174            return devs;
    175175       
    176         vector<uint> list;
    177         QMap<uint,bool> dups;
    178176        QFileInfoList::const_iterator it = il.begin();
    179177
    180178        for (; it != il.end(); ++it)
    181179        {
    182             if (it->fileName().left(7).lower() != "adapter")
     180            QDir subdir(it->filePath(), "frontend*", QDir::Name, QDir::Files | QDir::System);
     181            const QFileInfoList subil = subdir.entryInfoList();
     182            if (subil.isEmpty())
    183183                continue;
    184184
    185             bool ok;
    186             uint num = it->fileName().mid(7).toUInt(&ok);
    187             if (!ok || dups[num])
    188                 continue;
    189 
    190             list.push_back(num);
    191             dups[num] = true;
     185            QFileInfoList::const_iterator subit = subil.begin();
     186            for (; subit != subil.end(); ++subit)
     187                devs.push_back(subit->filePath());
    192188        }
    193 
    194         stable_sort(list.begin(), list.end());
    195 
    196         for (uint i = 0; i < list.size(); i++)
    197             devs.push_back(QString::number(list[i]));
    198189    }
    199190    else
    200191    {
    … …  
    205196    return devs;
    206197}
    207198
    208 QString CardUtil::ProbeDVBType(uint device)
     199QString CardUtil::ProbeDVBType(const QString &device)
    209200{
    210201    QString ret = "ERROR_UNKNOWN";
    211202    (void) device;
    … …  
    236227    return ret;
    237228}
    238229
    239 /** \fn CardUtil::ProbeDVBFrontendName(uint)
     230/** \fn CardUtil::ProbeDVBFrontendName(const QString &)
    240231 *  \brief Returns the card type from the video device
    241232 */
    242 QString CardUtil::ProbeDVBFrontendName(uint device)
     233QString CardUtil::ProbeDVBFrontendName(const QString &device)
    243234{
    244235    QString ret = "ERROR_UNKNOWN";
    245236    (void) device;
    … …  
    266257    return ret;
    267258}
    268259
    269 /** \fn CardUtil::HasDVBCRCBug(uint)
     260/** \fn CardUtil::HasDVBCRCBug(const QString &)
    270261 *  \brief Returns true if and only if the device munges
    271262 *         PAT/PMT tables, and then doesn't fix the CRC.
    272263 *
    … …  
    283274 *  \param device Open DVB frontend device file descriptor to be checked
    284275 *  \return true iff the device munges tables, so that they fail a CRC check.
    285276 */
    286 bool CardUtil::HasDVBCRCBug(uint device)
     277bool CardUtil::HasDVBCRCBug(const QString &device)
    287278{
    288279    QString name = ProbeDVBFrontendName(device);
    289280    return ((name == "VLSI VES1x93 DVB-S")      || // munges PMT
    290281            (name == "ST STV0299 DVB-S"));         // munges PAT
    291282}
    292283
    293 uint CardUtil::GetMinSignalMonitoringDelay(uint device)
     284uint CardUtil::GetMinSignalMonitoringDelay(const QString &device)
    294285{
    295286    QString name = ProbeDVBFrontendName(device);
    296287    if (name.find("DVB-S") >= 0)
    … …  
    311302    if (device.isEmpty())
    312303        return "ERROR_OPEN";
    313304
    314     return ProbeDVBType(device.toUInt());
     305    return ProbeDVBType(device);
    315306}
    316307
    317308/** \fn CardUtil::IsDVBCardType(const QString)
    … …  
    17341725}
    17351726
    17361727
    1737 QString CardUtil::GetDeviceName(dvb_dev_type_t type, uint cardnum)
     1728QString CardUtil::GetDeviceName(dvb_dev_type_t type, const QString &device)
    17381729{
     1730    QString devname = QString(device);
     1731    bool ok;
     1732    uint devnum = devname.toUInt(&ok);
     1733    if (ok)
     1734        devname = QString("/dev/dvb/adapter%1/frontend0").arg(devnum);
     1735
    17391736    if (DVB_DEV_FRONTEND == type)
    1740         return QString("/dev/dvb/adapter%1/frontend0").arg(cardnum);
     1737        return devname;
    17411738    else if (DVB_DEV_DVR == type)
    1742         return QString("/dev/dvb/adapter%1/dvr0").arg(cardnum);
     1739        return devname.replace(devname.find("frontend"), 8, "dvr");
    17431740    else if (DVB_DEV_DEMUX == type)
    1744         return QString("/dev/dvb/adapter%1/demux0").arg(cardnum);
     1741        return devname.replace(devname.find("frontend"), 8, "demux");
    17451742    else if (DVB_DEV_CA == type)
    1746         return QString("/dev/dvb/adapter%1/ca0").arg(cardnum);
     1743        return devname.replace(devname.find("frontend"), 8, "ca");
    17471744    else if (DVB_DEV_AUDIO == type)
    1748         return QString("/dev/dvb/adapter%1/audio0").arg(cardnum);
     1745        return devname.replace(devname.find("frontend"), 8, "audio");
    17491746    else if (DVB_DEV_VIDEO == type)
    1750         return QString("/dev/dvb/adapter%1/video0").arg(cardnum);
     1747        return devname.replace(devname.find("frontend"), 8, "video");
    17511748
    17521749    return "";
    17531750}

  • libs/libmythtv/videosource.cpp

     
    942942                        "should change to the name and type of your card. "
    943943                        "If the card cannot be opened, an error message "
    944944                        "will be displayed."));
    945         fillSelections(-1);
     945        fillSelections(QString());
    946946    };
    947947
    948948    /// \brief Adds all available cards to list
    949949    /// If current is >= 0 it will be considered available even
    950950    /// if no device exists for it in /dev/dvb/adapter*
    951     void fillSelections(int current)
     951    void fillSelections(const QString current)
    952952    {
    953953        clearSelections();
    954954
    955955        // Get devices from filesystem
    956956        vector<QString> sdevs = CardUtil::ProbeVideoDevices("DVB");
    957         vector<uint>    devs;
    958         for (uint i = 0; i < sdevs.size(); i++)
    959             devs.push_back(sdevs[i].toUInt());
    960957
    961958        // Add current if needed
    962         if ((current >= 0) &&
    963             (find(devs.begin(), devs.end(), (uint)current) == devs.end()))
     959        if (!current.isEmpty() && (find(sdevs.begin(), sdevs.end(), current) == sdevs.end()))
    964960        {
    965             devs.push_back(current);
    966             stable_sort(devs.begin(), devs.end());
     961            stable_sort(sdevs.begin(), sdevs.end());
    967962        }
    968963
    969964        vector<QString> db = CardUtil::GetVideoDevices("DVB");
    970965
    971         QMap<uint,bool> in_use;
    972         QString sel = (current >= 0) ? QString::number(current) : "";
    973         for (uint i = 0; i < devs.size(); i++)
     966        QMap<QString,bool> in_use;
     967        QString sel = current;
     968        for (uint i = 0; i < sdevs.size(); i++)
    974969        {
    975             const QString dev = QString::number(devs[i]);
    976             in_use[devs[i]] = find(db.begin(), db.end(), dev) != db.end();
    977             if (sel.isEmpty() && !in_use[devs[i]])
     970            const QString dev = sdevs[i];
     971            in_use[sdevs[i]] = find(db.begin(), db.end(), dev) != db.end();
     972            if (sel.isEmpty() && !in_use[sdevs[i]])
    978973                sel = dev;
    979974        }
    980975
    981         if (sel.isEmpty() && devs.size())
    982             sel = devs[0];
     976        if (sel.isEmpty() && sdevs.size())
     977            sel = sdevs[0];
    983978 
    984979        QString usestr = QString(" -- ");
    985980        usestr += QObject::tr("Warning: already in use");
    986981
    987         for (uint i = 0; i < devs.size(); i++)
     982        for (uint i = 0; i < sdevs.size(); i++)
    988983        {
    989             const QString dev = QString::number(devs[i]);
    990             QString desc = dev + (in_use[devs[i]] ? usestr : "");
    991             desc = ((uint)current == devs[i]) ? dev : desc;
     984            const QString dev = sdevs[i];
     985            QString desc = dev + (in_use[sdevs[i]] ? usestr : "");
     986            desc = (current == sdevs[i]) ? dev : desc;
    992987            addSelection(desc, dev, dev == sel);
    993988        }
    994989    }
    … …  
    996991    virtual void load(void)
    997992    {
    998993        clearSelections();
    999         addSelection("-1");
     994        addSelection(QString());
    1000995
    1001996        CaptureCardDBStorage::load();
    1002997
    1003         bool ok;
    1004         int intval = getValue().toInt(&ok);
    1005         intval = (ok) ? intval : -1;
    1006 
    1007         fillSelections(intval);
     998        QString dev = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, getValue());
     999        fillSelections(dev);
    10081000    }
    10091001};
    10101002
    … …  
    27322724    (void) videodevice;
    27332725
    27342726#ifdef USING_DVB
    2735     uint dvbdev = videodevice.toUInt();
    2736     QString frontend_name = CardUtil::ProbeDVBFrontendName(dvbdev);
    2737     QString subtype       = CardUtil::ProbeDVBType(dvbdev);
     2727    QString frontend_name = CardUtil::ProbeDVBFrontendName(videodevice);
     2728    QString subtype       = CardUtil::ProbeDVBType(videodevice);
    27382729
    2739     QString err_open  = tr("Could not open card #%1").arg(dvbdev);
    2740     QString err_other = tr("Could not get card info for card #%1").arg(dvbdev);
     2730    QString err_open  = tr("Could not open card %1").arg(videodevice);
     2731    QString err_other = tr("Could not get card info for card %1").arg(videodevice);
    27412732
    27422733    switch (CardUtil::toCardType(subtype))
    27432734    {

  • libs/libmythtv/dvbcam.cpp

     
    5858#include "dvbchannel.h"
    5959#include "dvbrecorder.h"
    6060
    61 #define LOC_ERR QString("DVB#%1 CA Error: ").arg(cardnum)
    62 #define LOC QString("DVB#%1 CA: ").arg(cardnum)
     61#define LOC_ERR QString("DVB#%1 CA Error: ").arg(device)
     62#define LOC QString("DVB#%1 CA: ").arg(device)
    6363
    64 DVBCam::DVBCam(int cardNum)
    65     : cardnum(cardNum),       numslots(0),
     64DVBCam::DVBCam(const QString &aDevice)
     65    : device(aDevice),        numslots(0),
    6666      ciHandler(NULL),
    6767      exitCiThread(false),    ciThreadRunning(false),
    6868      have_pmt(false),        pmt_sent(false),
    6969      pmt_updated(false),     pmt_added(false)
    7070{
    71     QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, cardnum);
     71    QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, device);
    7272    int cafd = open(dvbdev.ascii(), O_RDWR);
    7373    if (cafd >= 0)
    7474    {
    … …  
    9595    pmt_updated  = false;
    9696    pmt_added    = false;
    9797
    98     QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, cardnum);
     98    QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, device);
    9999    ciHandler = cCiHandler::CreateCiHandler(dvbdev.ascii());
    100100    if (!ciHandler)
    101101    {

  • libs/libmythtv/dvbstreamhandler.cpp

     
    2222#include "dvbtypes.h" // for pid filtering
    2323#include "diseqc.h" // for rotor retune
    2424
    25 #define LOC      QString("DVBSH(%1): ").arg(_dvb_dev_num)
    26 #define LOC_WARN QString("DVBSH(%1) Warning: ").arg(_dvb_dev_num)
    27 #define LOC_ERR  QString("DVBSH(%1) Error: ").arg(_dvb_dev_num)
     25#define LOC      QString("DVBSH(%1): ").arg(_dvb_dev)
     26#define LOC_WARN QString("DVBSH(%1) Warning: ").arg(_dvb_dev)
     27#define LOC_ERR  QString("DVBSH(%1) Error: ").arg(_dvb_dev)
    2828
    29 QMap<uint,bool> DVBStreamHandler::_rec_supports_ts_monitoring;
    30 QMutex          DVBStreamHandler::_rec_supports_ts_monitoring_lock;
     29QMap<QString,bool> DVBStreamHandler::_rec_supports_ts_monitoring;
     30QMutex             DVBStreamHandler::_rec_supports_ts_monitoring_lock;
    3131
    32 QMap<uint,DVBStreamHandler*> DVBStreamHandler::_handlers;
    33 QMap<uint,uint>              DVBStreamHandler::_handlers_refcnt;
    34 QMutex                       DVBStreamHandler::_handlers_lock;
     32QMap<QString,DVBStreamHandler*> DVBStreamHandler::_handlers;
     33QMap<QString,uint>              DVBStreamHandler::_handlers_refcnt;
     34QMutex                          DVBStreamHandler::_handlers_lock;
    3535
    36 DVBStreamHandler *DVBStreamHandler::Get(uint dvb_device_number)
     36DVBStreamHandler *DVBStreamHandler::Get(const QString &dvb_device)
    3737{
    3838    QMutexLocker locker(&_handlers_lock);
    3939
    40     QMap<uint,DVBStreamHandler*>::iterator it =
    41         _handlers.find(dvb_device_number);
     40    QMap<QString,DVBStreamHandler*>::iterator it =
     41        _handlers.find(dvb_device);
    4242
    4343    if (it == _handlers.end())
    4444    {
    45         _handlers[dvb_device_number] = new DVBStreamHandler(dvb_device_number);
    46         _handlers_refcnt[dvb_device_number] = 1;
     45        _handlers[dvb_device] = new DVBStreamHandler(dvb_device);
     46        _handlers_refcnt[dvb_device] = 1;
    4747    }
    4848    else
    4949    {
    50         _handlers_refcnt[dvb_device_number]++;
     50        _handlers_refcnt[dvb_device]++;
    5151    }
    5252
    53     return _handlers[dvb_device_number];
     53    return _handlers[dvb_device];
    5454}
    5555
    5656void DVBStreamHandler::Return(DVBStreamHandler * & ref)
    5757{
    5858    QMutexLocker locker(&_handlers_lock);
    5959
    60     uint dvb_dev_num = ref->_dvb_dev_num;
     60    QString dvb_dev = ref->_dvb_dev;
    6161
    62     QMap<uint,uint>::iterator rit = _handlers_refcnt.find(dvb_dev_num);
     62    QMap<QString,uint>::iterator rit = _handlers_refcnt.find(dvb_dev);
    6363    if (rit == _handlers_refcnt.end())
    6464        return;
    6565
    … …  
    6969        return;
    7070    }
    7171
    72     QMap<uint,DVBStreamHandler*>::iterator it = _handlers.find(dvb_dev_num);
     72    QMap<QString,DVBStreamHandler*>::iterator it = _handlers.find(dvb_dev);
    7373    if ((it != _handlers.end()) && (*it == ref))
    7474    {
    7575        ref = NULL;
    … …  
    8080    _handlers_refcnt.erase(rit);
    8181}
    8282
    83 DVBStreamHandler::DVBStreamHandler(uint dvb_device_number) :
    84     _dvb_dev_num(dvb_device_number),
    85     _dvr_dev_path(CardUtil::GetDeviceName(DVB_DEV_DVR, _dvb_dev_num)),
     83DVBStreamHandler::DVBStreamHandler(const QString &dvb_device) :
     84    _dvb_dev(dvb_device),
     85    _dvr_dev_path(CardUtil::GetDeviceName(DVB_DEV_DVR, _dvb_dev)),
    8686    _allow_section_reader(false),
    8787    _needs_buffering(false),
    8888    _allow_retune(false),
    … …  
    259259    bool _error = false;
    260260    if (_device_read_buffer)
    261261    {
    262         bool ok = _device_read_buffer->Setup(
    263             QString::number(_dvb_dev_num), dvr_fd);
     262        bool ok = _device_read_buffer->Setup(_dvb_dev, dvr_fd);
    264263
    265264        if (!ok)
    266265        {
    … …  
    501500            if (closed == priority_queue[i].end())
    502501                break; // something is broken
    503502
    504             if (_pid_info[*closed]->Open(_dvb_dev_num, _using_section_reader))
     503            if (_pid_info[*closed]->Open(_dvb_dev, _using_section_reader))
    505504            {
    506505                _open_pid_filters++;
    507506                priority_open_cnt[i]++;
    … …  
    523522                    if (!info->IsOpen())
    524523                        continue;
    525524
    526                     if (info->Close(_dvb_dev_num))
     525                    if (info->Close(_dvb_dev))
    527526                        freed = true;
    528527
    529528                    _open_pid_filters--;
    … …  
    535534            {
    536535                // if we can open a filter, just do it
    537536                if (_pid_info[*closed]->Open(
    538                         _dvb_dev_num, _using_section_reader))
     537                        _dvb_dev, _using_section_reader))
    539538                {
    540539                    _open_pid_filters++;
    541540                    priority_open_cnt[i]++;
    … …  
    552551                break; // nothing to close..
    553552
    554553            // close "open"
    555             bool ok = _pid_info[*open]->Close(_dvb_dev_num);
     554            bool ok = _pid_info[*open]->Close(_dvb_dev);
    556555            _open_pid_filters--;
    557556            priority_open_cnt[i]--;
    558557
    559558            // open "closed"
    560559            if (ok && _pid_info[*closed]->
    561                 Open(_dvb_dev_num, _using_section_reader))
     560                Open(_dvb_dev, _using_section_reader))
    562561            {
    563562                _open_pid_filters++;
    564563                priority_open_cnt[i]++;
    … …  
    588587    bool ok = true;
    589588    if (tmp->IsOpen())
    590589    {
    591         ok = tmp->Close(_dvb_dev_num);
     590        ok = tmp->Close(_dvb_dev);
    592591        _open_pid_filters--;
    593592
    594593        CycleFiltersByPriority();
    … …  
    769768
    770769    {
    771770        QMutexLocker locker(&_rec_supports_ts_monitoring_lock);
    772         QMap<uint,bool>::const_iterator it;
    773         it = _rec_supports_ts_monitoring.find(_dvb_dev_num);
     771        QMap<QString,bool>::const_iterator it;
     772        it = _rec_supports_ts_monitoring.find(_dvb_dev);
    774773        if (it != _rec_supports_ts_monitoring.end())
    775774            return *it;
    776775    }
    … …  
    779778    if (dvr_fd < 0)
    780779    {
    781780        QMutexLocker locker(&_rec_supports_ts_monitoring_lock);
    782         _rec_supports_ts_monitoring[_dvb_dev_num] = false;
     781        _rec_supports_ts_monitoring[_dvb_dev] = false;
    783782        return false;
    784783    }
    785784
    … …  
    793792    close(dvr_fd);
    794793
    795794    QMutexLocker locker(&_rec_supports_ts_monitoring_lock);
    796     _rec_supports_ts_monitoring[_dvb_dev_num] = supports_ts;
     795    _rec_supports_ts_monitoring[_dvb_dev] = supports_ts;
    797796
    798797    return supports_ts;
    799798}
    … …  
    802801#undef LOC_WARN
    803802#undef LOC_ERR
    804803
    805 #define LOC      QString("PIDInfo(%1): ").arg(dvb_dev_num)
    806 #define LOC_WARN QString("PIDInfo(%1) Warning: ").arg(dvb_dev_num)
    807 #define LOC_ERR  QString("PIDInfo(%1) Error: ").arg(dvb_dev_num)
     804#define LOC      QString("PIDInfo(%1): ").arg(dvb_dev)
     805#define LOC_WARN QString("PIDInfo(%1) Warning: ").arg(dvb_dev)
     806#define LOC_ERR  QString("PIDInfo(%1) Error: ").arg(dvb_dev)
    808807
    809 bool PIDInfo::Open(uint dvb_dev_num, bool use_section_reader)
     808bool PIDInfo::Open(const QString &dvb_dev, bool use_section_reader)
    810809{
    811810    if (filter_fd >= 0)
    812811    {
    … …  
    814813        filter_fd = -1;
    815814    }
    816815
    817     QString demux_fn = CardUtil::GetDeviceName(DVB_DEV_DEMUX, dvb_dev_num);
     816    QString demux_fn = CardUtil::GetDeviceName(DVB_DEV_DEMUX, dvb_dev);
    818817
    819818    VERBOSE(VB_RECORD, LOC + QString("Opening filter for pid 0x%1")
    820819            .arg(_pid, 0, 16));
    … …  
    909908    return true;
    910909}
    911910
    912 bool PIDInfo::Close(uint dvb_dev_num)
     911bool PIDInfo::Close(const QString &dvb_dev)
    913912{
    914913    VERBOSE(VB_RECORD, LOC +
    915914            QString("Closing filter for pid 0x%1").arg(_pid, 0, 16));

  • libs/libmythtv/tv_rec.cpp

     
    142142    if (genOpt.cardtype == "DVB")
    143143    {
    144144#ifdef USING_DVB
    145         channel = new DVBChannel(genOpt.videodev.toInt(), this);
     145        channel = new DVBChannel(genOpt.videodev, this);
    146146        if (!channel->Open())
    147147            return false;
    148148        GetDVBChannel()->SetSlowTuning(dvbOpt.dvb_tuning_delay);