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

File multiple-dvb-frontends-trunk.patch, 28.8 KB (added by Paul Kendall <paul@…>, 4 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);