Index: libs/libmythtv/dvbrecorder.cpp =================================================================== --- libs/libmythtv/dvbrecorder.cpp (revision 16990) +++ libs/libmythtv/dvbrecorder.cpp (working copy) @@ -94,8 +94,6 @@ DVBRecorder::DVBRecorder(TVRec *rec, DVBChannel* advbchannel) : DTVRecorder(rec), - // Options set in SetOption() - _card_number_option(0), // DVB stuff dvbchannel(advbchannel), _stream_handler(NULL), @@ -145,12 +143,12 @@ } } -void DVBRecorder::SetOption(const QString &name, int value) +void DVBRecorder::SetOption(const QString &name, const QString &value) { if (name == "cardnum") { _card_number_option = value; - videodevice = QString::number(value); + videodevice = value; } else DTVRecorder::SetOption(name, value); @@ -160,7 +158,7 @@ const QString &videodev, const QString&, const QString&) { - SetOption("cardnum", videodev.toInt()); + SetOption("cardnum", videodev); DTVRecorder::SetOption("tvformat", gContext->GetSetting("TVFormat")); SetStrOption(profile, "recordingtype"); } @@ -318,7 +316,7 @@ return true; } - if (_card_number_option < 0) + if (_card_number_option.isEmpty()) return false; bzero(_stream_id, sizeof(_stream_id)); Index: libs/libmythtv/cardutil.h =================================================================== --- libs/libmythtv/cardutil.h (revision 16990) +++ libs/libmythtv/cardutil.h (working copy) @@ -221,11 +221,11 @@ static bool IsDVB(uint cardid) { return "DVB" == GetRawCardType(cardid); } static bool IsDVBCardType(const QString card_type); - static QString ProbeDVBFrontendName(uint device); - static QString ProbeDVBType(uint device); - static bool HasDVBCRCBug(uint device); - static uint GetMinSignalMonitoringDelay(uint device); - static QString GetDeviceName(dvb_dev_type_t, uint cardnum); + static QString ProbeDVBFrontendName(const QString &device); + static QString ProbeDVBType(const QString &device); + static bool HasDVBCRCBug(const QString &device); + static uint GetMinSignalMonitoringDelay(const QString &device); + static QString GetDeviceName(dvb_dev_type_t, const QString &device); static InputNames GetConfiguredDVBInputs(uint cardid); // V4L info Index: libs/libmythtv/dvbrecorder.h =================================================================== --- libs/libmythtv/dvbrecorder.h (revision 16990) +++ libs/libmythtv/dvbrecorder.h (working copy) @@ -49,7 +49,7 @@ DVBRecorder(TVRec *rec, DVBChannel* dvbchannel); ~DVBRecorder(); - void SetOption(const QString &name, int value); + void SetOption(const QString &name, const QString &value); void SetOptionsFromProfile(RecordingProfile *profile, const QString &videodev, @@ -108,7 +108,7 @@ private: // Options set in SetOption() - int _card_number_option; + QString _card_number_option; // DVB stuff DVBChannel *dvbchannel; Index: libs/libmythtv/scanwizardscanner.cpp =================================================================== --- libs/libmythtv/scanwizardscanner.cpp (revision 16990) +++ libs/libmythtv/scanwizardscanner.cpp (working copy) @@ -402,7 +402,7 @@ ok = !device.isEmpty(); if (ok) - sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper(); + sub_type = CardUtil::ProbeDVBType(device).upper(); } if (ok) @@ -488,7 +488,7 @@ if ("DVB" == card_type) { - QString sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper(); + QString sub_type = CardUtil::ProbeDVBType(device).upper(); bool need_nit = (("QAM" == sub_type) || ("QPSK" == sub_type) || ("OFDM" == sub_type)); @@ -508,7 +508,7 @@ #ifdef USING_DVB if ("DVB" == card_type) - channel = new DVBChannel(device.toInt()); + channel = new DVBChannel(device); #endif #ifdef USING_V4L Index: libs/libmythtv/dvbstreamhandler.h =================================================================== --- libs/libmythtv/dvbstreamhandler.h (revision 16990) +++ libs/libmythtv/dvbstreamhandler.h (working copy) @@ -34,8 +34,8 @@ _pid(pid), filter_fd(-1), streamType(stream_type), pesType(pes_type) {;} - bool Open(uint dvb_dev_num, bool use_section_reader); - bool Close(uint dvb_dev_num); + bool Open(const QString &dvb_dev, bool use_section_reader); + bool Close(const QString &dvb_dev); bool IsOpen(void) const { return filter_fd >= 0; } uint _pid; @@ -50,7 +50,7 @@ friend void *run_dvb_stream_handler_thunk(void *param); public: - static DVBStreamHandler *Get(uint dvb_device_number); + static DVBStreamHandler *Get(const QString &dvb_device); static void Return(DVBStreamHandler * & ref); void AddListener(MPEGStreamData *data, @@ -71,7 +71,7 @@ virtual void ReaderPaused(int fd) { (void) fd; } private: - DVBStreamHandler(uint); + DVBStreamHandler(const QString &); ~DVBStreamHandler(); void Start(void); @@ -94,7 +94,7 @@ bool SupportsTSMonitoring(void); private: - uint _dvb_dev_num; + QString _dvb_dev; QString _dvr_dev_path; bool _allow_section_reader; bool _needs_buffering; @@ -119,13 +119,13 @@ vector _stream_data_list; // for caching TS monitoring supported value. - static QMutex _rec_supports_ts_monitoring_lock; - static QMap _rec_supports_ts_monitoring; + static QMutex _rec_supports_ts_monitoring_lock; + static QMap _rec_supports_ts_monitoring; // for implementing Get & Return - static QMutex _handlers_lock; - static QMap _handlers; - static QMap _handlers_refcnt; + static QMutex _handlers_lock; + static QMap _handlers; + static QMap _handlers_refcnt; }; #endif // _DVBSTREAMHANDLER_H_ Index: libs/libmythtv/dvbchannel.h =================================================================== --- libs/libmythtv/dvbchannel.h (revision 16990) +++ libs/libmythtv/dvbchannel.h (working copy) @@ -28,7 +28,7 @@ class DVBChannel : public DTVChannel { public: - DVBChannel(int cardnum, TVRec *parent = NULL); + DVBChannel(const QString &device, TVRec *parent = NULL); ~DVBChannel(); bool Open(void) { return Open(this); } @@ -47,9 +47,9 @@ int GetFd(void) const { return fd_frontend; } bool IsTuningParamsProbeSupported(void) const; - QString GetDevice(void) const { return QString::number(GetCardNum()); } + QString GetDevice(void) const { return device; } /// Returns DVB device number, used to construct filenames for DVB devices - int GetCardNum(void) const { return cardnum; }; + QString GetCardNum(void) const { return device; }; /// Returns frontend name as reported by driver QString GetFrontendName(void) const; DTVTunerType GetCardType(void) const { return card_type; } @@ -139,7 +139,7 @@ // Other State int fd_frontend; ///< File descriptor for tuning hardware - int cardnum; ///< DVB Card number + QString device; ///< DVB Device bool has_crc_bug; ///< true iff our driver munges PMT int nextInputID; ///< Signal an input change }; Index: libs/libmythtv/dvbcam.h =================================================================== --- libs/libmythtv/dvbcam.h (revision 16990) +++ libs/libmythtv/dvbcam.h (working copy) @@ -17,7 +17,7 @@ class DVBCam { public: - DVBCam(int cardnum); + DVBCam(const QString &device); ~DVBCam(); bool Start(); @@ -34,7 +34,7 @@ void SendPMT(const ProgramMapTable &pmt, uint cplm); - int cardnum; + QString device; int numslots; cCiHandler *ciHandler; Index: libs/libmythtv/dvbchannel.cpp =================================================================== --- libs/libmythtv/dvbchannel.cpp (revision 16990) +++ libs/libmythtv/dvbchannel.cpp (working copy) @@ -55,17 +55,17 @@ static DTVMultiplex dvbparams_to_dtvmultiplex( DTVTunerType, const dvb_fe_params&); -#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(cardnum) +#define LOC QString("DVBChan(%1:%2): ").arg(GetCardID()).arg(device) #define LOC_WARN QString("DVBChan(%1:%2) Warning: ") \ - .arg(GetCardID()).arg(cardnum) -#define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(cardnum) + .arg(GetCardID()).arg(device) +#define LOC_ERR QString("DVBChan(%1:%2) Error: ").arg(GetCardID()).arg(device) /** \class DVBChannel * \brief Provides interface to the tuning hardware when using DVB drivers * * \bug Only supports single input cards. */ -DVBChannel::DVBChannel(int aCardNum, TVRec *parent) +DVBChannel::DVBChannel(const QString &aDevice, TVRec *parent) : DTVChannel(parent), master(NULL), // Helper classes diseqc_tree(NULL), dvbcam(NULL), @@ -77,17 +77,17 @@ tuning_delay(0), sigmon_delay(25), first_tune(true), // Misc - fd_frontend(-1), cardnum(aCardNum), + fd_frontend(-1), device(aDevice), has_crc_bug(false) { - QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, cardnum); + QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, device); master = dynamic_cast(GetMaster(devname)); master = (master == this) ? NULL : master; if (!master) { - dvbcam = new DVBCam(cardnum); - has_crc_bug = CardUtil::HasDVBCRCBug(aCardNum); + dvbcam = new DVBCam(device); + has_crc_bug = CardUtil::HasDVBCRCBug(device); } else { @@ -95,7 +95,7 @@ has_crc_bug = master->has_crc_bug; } - sigmon_delay = CardUtil::GetMinSignalMonitoringDelay(aCardNum); + sigmon_delay = CardUtil::GetMinSignalMonitoringDelay(device); } DVBChannel::~DVBChannel() @@ -187,7 +187,7 @@ return true; } - QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, cardnum); + QString devname = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, device); fd_frontend = open(devname.ascii(), O_RDWR | O_NONBLOCK); if (fd_frontend < 0) @@ -262,7 +262,7 @@ symbol_rate_maximum = info.symbol_rate_max; VERBOSE(VB_RECORD, LOC + QString("Using DVB card %1, with frontend '%2'.") - .arg(cardnum).arg(frontend_name)); + .arg(device).arg(frontend_name)); // Turn on the power to the LNB if (card_type == DTVTunerType::kTunerTypeQPSK || Index: libs/libmythtv/cardutil.cpp =================================================================== --- libs/libmythtv/cardutil.cpp (revision 16990) +++ libs/libmythtv/cardutil.cpp (working copy) @@ -168,33 +168,24 @@ if (rawtype.upper() == "DVB") { - QDir dir("/dev/dvb", "adapter*", QDir::Name, QDir::All); + QDir dir("/dev/dvb", "adapter*", QDir::Name, QDir::Dirs); const QFileInfoList il = dir.entryInfoList(); if (il.isEmpty()) return devs; - vector list; - QMap dups; QFileInfoList::const_iterator it = il.begin(); for (; it != il.end(); ++it) { - if (it->fileName().left(7).lower() != "adapter") + QDir subdir(it->filePath(), "frontend*", QDir::Name, QDir::Files | QDir::System); + const QFileInfoList subil = subdir.entryInfoList(); + if (subil.isEmpty()) continue; - bool ok; - uint num = it->fileName().mid(7).toUInt(&ok); - if (!ok || dups[num]) - continue; - - list.push_back(num); - dups[num] = true; + QFileInfoList::const_iterator subit = subil.begin(); + for (; subit != subil.end(); ++subit) + devs.push_back(subit->filePath()); } - - stable_sort(list.begin(), list.end()); - - for (uint i = 0; i < list.size(); i++) - devs.push_back(QString::number(list[i])); } else { @@ -205,7 +196,7 @@ return devs; } -QString CardUtil::ProbeDVBType(uint device) +QString CardUtil::ProbeDVBType(const QString &device) { QString ret = "ERROR_UNKNOWN"; (void) device; @@ -236,10 +227,10 @@ return ret; } -/** \fn CardUtil::ProbeDVBFrontendName(uint) +/** \fn CardUtil::ProbeDVBFrontendName(const QString &) * \brief Returns the card type from the video device */ -QString CardUtil::ProbeDVBFrontendName(uint device) +QString CardUtil::ProbeDVBFrontendName(const QString &device) { QString ret = "ERROR_UNKNOWN"; (void) device; @@ -266,7 +257,7 @@ return ret; } -/** \fn CardUtil::HasDVBCRCBug(uint) +/** \fn CardUtil::HasDVBCRCBug(const QString &) * \brief Returns true if and only if the device munges * PAT/PMT tables, and then doesn't fix the CRC. * @@ -283,14 +274,14 @@ * \param device Open DVB frontend device file descriptor to be checked * \return true iff the device munges tables, so that they fail a CRC check. */ -bool CardUtil::HasDVBCRCBug(uint device) +bool CardUtil::HasDVBCRCBug(const QString &device) { QString name = ProbeDVBFrontendName(device); return ((name == "VLSI VES1x93 DVB-S") || // munges PMT (name == "ST STV0299 DVB-S")); // munges PAT } -uint CardUtil::GetMinSignalMonitoringDelay(uint device) +uint CardUtil::GetMinSignalMonitoringDelay(const QString &device) { QString name = ProbeDVBFrontendName(device); if (name.find("DVB-S") >= 0) @@ -311,7 +302,7 @@ if (device.isEmpty()) return "ERROR_OPEN"; - return ProbeDVBType(device.toUInt()); + return ProbeDVBType(device); } /** \fn CardUtil::IsDVBCardType(const QString) @@ -1734,20 +1725,26 @@ } -QString CardUtil::GetDeviceName(dvb_dev_type_t type, uint cardnum) +QString CardUtil::GetDeviceName(dvb_dev_type_t type, const QString &device) { + QString devname = QString(device); + bool ok; + uint devnum = devname.toUInt(&ok); + if (ok) + devname = QString("/dev/dvb/adapter%1/frontend0").arg(devnum); + if (DVB_DEV_FRONTEND == type) - return QString("/dev/dvb/adapter%1/frontend0").arg(cardnum); + return devname; else if (DVB_DEV_DVR == type) - return QString("/dev/dvb/adapter%1/dvr0").arg(cardnum); + return devname.replace(devname.find("frontend"), 8, "dvr"); else if (DVB_DEV_DEMUX == type) - return QString("/dev/dvb/adapter%1/demux0").arg(cardnum); + return devname.replace(devname.find("frontend"), 8, "demux"); else if (DVB_DEV_CA == type) - return QString("/dev/dvb/adapter%1/ca0").arg(cardnum); + return devname.replace(devname.find("frontend"), 8, "ca"); else if (DVB_DEV_AUDIO == type) - return QString("/dev/dvb/adapter%1/audio0").arg(cardnum); + return devname.replace(devname.find("frontend"), 8, "audio"); else if (DVB_DEV_VIDEO == type) - return QString("/dev/dvb/adapter%1/video0").arg(cardnum); + return devname.replace(devname.find("frontend"), 8, "video"); return ""; } Index: libs/libmythtv/videosource.cpp =================================================================== --- libs/libmythtv/videosource.cpp (revision 16990) +++ libs/libmythtv/videosource.cpp (working copy) @@ -942,53 +942,48 @@ "should change to the name and type of your card. " "If the card cannot be opened, an error message " "will be displayed.")); - fillSelections(-1); + fillSelections(QString()); }; /// \brief Adds all available cards to list /// If current is >= 0 it will be considered available even /// if no device exists for it in /dev/dvb/adapter* - void fillSelections(int current) + void fillSelections(const QString current) { clearSelections(); // Get devices from filesystem vector sdevs = CardUtil::ProbeVideoDevices("DVB"); - vector devs; - for (uint i = 0; i < sdevs.size(); i++) - devs.push_back(sdevs[i].toUInt()); // Add current if needed - if ((current >= 0) && - (find(devs.begin(), devs.end(), (uint)current) == devs.end())) + if (!current.isEmpty() && (find(sdevs.begin(), sdevs.end(), current) == sdevs.end())) { - devs.push_back(current); - stable_sort(devs.begin(), devs.end()); + stable_sort(sdevs.begin(), sdevs.end()); } vector db = CardUtil::GetVideoDevices("DVB"); - QMap in_use; - QString sel = (current >= 0) ? QString::number(current) : ""; - for (uint i = 0; i < devs.size(); i++) + QMap in_use; + QString sel = current; + for (uint i = 0; i < sdevs.size(); i++) { - const QString dev = QString::number(devs[i]); - in_use[devs[i]] = find(db.begin(), db.end(), dev) != db.end(); - if (sel.isEmpty() && !in_use[devs[i]]) + const QString dev = sdevs[i]; + in_use[sdevs[i]] = find(db.begin(), db.end(), dev) != db.end(); + if (sel.isEmpty() && !in_use[sdevs[i]]) sel = dev; } - if (sel.isEmpty() && devs.size()) - sel = devs[0]; + if (sel.isEmpty() && sdevs.size()) + sel = sdevs[0]; QString usestr = QString(" -- "); usestr += QObject::tr("Warning: already in use"); - for (uint i = 0; i < devs.size(); i++) + for (uint i = 0; i < sdevs.size(); i++) { - const QString dev = QString::number(devs[i]); - QString desc = dev + (in_use[devs[i]] ? usestr : ""); - desc = ((uint)current == devs[i]) ? dev : desc; + const QString dev = sdevs[i]; + QString desc = dev + (in_use[sdevs[i]] ? usestr : ""); + desc = (current == sdevs[i]) ? dev : desc; addSelection(desc, dev, dev == sel); } } @@ -996,15 +991,12 @@ virtual void load(void) { clearSelections(); - addSelection("-1"); + addSelection(QString()); CaptureCardDBStorage::load(); - bool ok; - int intval = getValue().toInt(&ok); - intval = (ok) ? intval : -1; - - fillSelections(intval); + QString dev = CardUtil::GetDeviceName(DVB_DEV_FRONTEND, getValue()); + fillSelections(dev); } }; @@ -2732,12 +2724,11 @@ (void) videodevice; #ifdef USING_DVB - uint dvbdev = videodevice.toUInt(); - QString frontend_name = CardUtil::ProbeDVBFrontendName(dvbdev); - QString subtype = CardUtil::ProbeDVBType(dvbdev); + QString frontend_name = CardUtil::ProbeDVBFrontendName(videodevice); + QString subtype = CardUtil::ProbeDVBType(videodevice); - QString err_open = tr("Could not open card #%1").arg(dvbdev); - QString err_other = tr("Could not get card info for card #%1").arg(dvbdev); + QString err_open = tr("Could not open card %1").arg(videodevice); + QString err_other = tr("Could not get card info for card %1").arg(videodevice); switch (CardUtil::toCardType(subtype)) { Index: libs/libmythtv/dvbcam.cpp =================================================================== --- libs/libmythtv/dvbcam.cpp (revision 16990) +++ libs/libmythtv/dvbcam.cpp (working copy) @@ -58,17 +58,17 @@ #include "dvbchannel.h" #include "dvbrecorder.h" -#define LOC_ERR QString("DVB#%1 CA Error: ").arg(cardnum) -#define LOC QString("DVB#%1 CA: ").arg(cardnum) +#define LOC_ERR QString("DVB#%1 CA Error: ").arg(device) +#define LOC QString("DVB#%1 CA: ").arg(device) -DVBCam::DVBCam(int cardNum) - : cardnum(cardNum), numslots(0), +DVBCam::DVBCam(const QString &aDevice) + : device(aDevice), numslots(0), ciHandler(NULL), exitCiThread(false), ciThreadRunning(false), have_pmt(false), pmt_sent(false), pmt_updated(false), pmt_added(false) { - QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, cardnum); + QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, device); int cafd = open(dvbdev.ascii(), O_RDWR); if (cafd >= 0) { @@ -95,7 +95,7 @@ pmt_updated = false; pmt_added = false; - QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, cardnum); + QString dvbdev = CardUtil::GetDeviceName(DVB_DEV_CA, device); ciHandler = cCiHandler::CreateCiHandler(dvbdev.ascii()); if (!ciHandler) { Index: libs/libmythtv/dvbstreamhandler.cpp =================================================================== --- libs/libmythtv/dvbstreamhandler.cpp (revision 16990) +++ libs/libmythtv/dvbstreamhandler.cpp (working copy) @@ -22,44 +22,44 @@ #include "dvbtypes.h" // for pid filtering #include "diseqc.h" // for rotor retune -#define LOC QString("DVBSH(%1): ").arg(_dvb_dev_num) -#define LOC_WARN QString("DVBSH(%1) Warning: ").arg(_dvb_dev_num) -#define LOC_ERR QString("DVBSH(%1) Error: ").arg(_dvb_dev_num) +#define LOC QString("DVBSH(%1): ").arg(_dvb_dev) +#define LOC_WARN QString("DVBSH(%1) Warning: ").arg(_dvb_dev) +#define LOC_ERR QString("DVBSH(%1) Error: ").arg(_dvb_dev) -QMap DVBStreamHandler::_rec_supports_ts_monitoring; -QMutex DVBStreamHandler::_rec_supports_ts_monitoring_lock; +QMap DVBStreamHandler::_rec_supports_ts_monitoring; +QMutex DVBStreamHandler::_rec_supports_ts_monitoring_lock; -QMap DVBStreamHandler::_handlers; -QMap DVBStreamHandler::_handlers_refcnt; -QMutex DVBStreamHandler::_handlers_lock; +QMap DVBStreamHandler::_handlers; +QMap DVBStreamHandler::_handlers_refcnt; +QMutex DVBStreamHandler::_handlers_lock; -DVBStreamHandler *DVBStreamHandler::Get(uint dvb_device_number) +DVBStreamHandler *DVBStreamHandler::Get(const QString &dvb_device) { QMutexLocker locker(&_handlers_lock); - QMap::iterator it = - _handlers.find(dvb_device_number); + QMap::iterator it = + _handlers.find(dvb_device); if (it == _handlers.end()) { - _handlers[dvb_device_number] = new DVBStreamHandler(dvb_device_number); - _handlers_refcnt[dvb_device_number] = 1; + _handlers[dvb_device] = new DVBStreamHandler(dvb_device); + _handlers_refcnt[dvb_device] = 1; } else { - _handlers_refcnt[dvb_device_number]++; + _handlers_refcnt[dvb_device]++; } - return _handlers[dvb_device_number]; + return _handlers[dvb_device]; } void DVBStreamHandler::Return(DVBStreamHandler * & ref) { QMutexLocker locker(&_handlers_lock); - uint dvb_dev_num = ref->_dvb_dev_num; + QString dvb_dev = ref->_dvb_dev; - QMap::iterator rit = _handlers_refcnt.find(dvb_dev_num); + QMap::iterator rit = _handlers_refcnt.find(dvb_dev); if (rit == _handlers_refcnt.end()) return; @@ -69,7 +69,7 @@ return; } - QMap::iterator it = _handlers.find(dvb_dev_num); + QMap::iterator it = _handlers.find(dvb_dev); if ((it != _handlers.end()) && (*it == ref)) { ref = NULL; @@ -80,9 +80,9 @@ _handlers_refcnt.erase(rit); } -DVBStreamHandler::DVBStreamHandler(uint dvb_device_number) : - _dvb_dev_num(dvb_device_number), - _dvr_dev_path(CardUtil::GetDeviceName(DVB_DEV_DVR, _dvb_dev_num)), +DVBStreamHandler::DVBStreamHandler(const QString &dvb_device) : + _dvb_dev(dvb_device), + _dvr_dev_path(CardUtil::GetDeviceName(DVB_DEV_DVR, _dvb_dev)), _allow_section_reader(false), _needs_buffering(false), _allow_retune(false), @@ -259,8 +259,7 @@ bool _error = false; if (_device_read_buffer) { - bool ok = _device_read_buffer->Setup( - QString::number(_dvb_dev_num), dvr_fd); + bool ok = _device_read_buffer->Setup(_dvb_dev, dvr_fd); if (!ok) { @@ -501,7 +500,7 @@ if (closed == priority_queue[i].end()) break; // something is broken - if (_pid_info[*closed]->Open(_dvb_dev_num, _using_section_reader)) + if (_pid_info[*closed]->Open(_dvb_dev, _using_section_reader)) { _open_pid_filters++; priority_open_cnt[i]++; @@ -523,7 +522,7 @@ if (!info->IsOpen()) continue; - if (info->Close(_dvb_dev_num)) + if (info->Close(_dvb_dev)) freed = true; _open_pid_filters--; @@ -535,7 +534,7 @@ { // if we can open a filter, just do it if (_pid_info[*closed]->Open( - _dvb_dev_num, _using_section_reader)) + _dvb_dev, _using_section_reader)) { _open_pid_filters++; priority_open_cnt[i]++; @@ -552,13 +551,13 @@ break; // nothing to close.. // close "open" - bool ok = _pid_info[*open]->Close(_dvb_dev_num); + bool ok = _pid_info[*open]->Close(_dvb_dev); _open_pid_filters--; priority_open_cnt[i]--; // open "closed" if (ok && _pid_info[*closed]-> - Open(_dvb_dev_num, _using_section_reader)) + Open(_dvb_dev, _using_section_reader)) { _open_pid_filters++; priority_open_cnt[i]++; @@ -588,7 +587,7 @@ bool ok = true; if (tmp->IsOpen()) { - ok = tmp->Close(_dvb_dev_num); + ok = tmp->Close(_dvb_dev); _open_pid_filters--; CycleFiltersByPriority(); @@ -769,8 +768,8 @@ { QMutexLocker locker(&_rec_supports_ts_monitoring_lock); - QMap::const_iterator it; - it = _rec_supports_ts_monitoring.find(_dvb_dev_num); + QMap::const_iterator it; + it = _rec_supports_ts_monitoring.find(_dvb_dev); if (it != _rec_supports_ts_monitoring.end()) return *it; } @@ -779,7 +778,7 @@ if (dvr_fd < 0) { QMutexLocker locker(&_rec_supports_ts_monitoring_lock); - _rec_supports_ts_monitoring[_dvb_dev_num] = false; + _rec_supports_ts_monitoring[_dvb_dev] = false; return false; } @@ -793,7 +792,7 @@ close(dvr_fd); QMutexLocker locker(&_rec_supports_ts_monitoring_lock); - _rec_supports_ts_monitoring[_dvb_dev_num] = supports_ts; + _rec_supports_ts_monitoring[_dvb_dev] = supports_ts; return supports_ts; } @@ -802,11 +801,11 @@ #undef LOC_WARN #undef LOC_ERR -#define LOC QString("PIDInfo(%1): ").arg(dvb_dev_num) -#define LOC_WARN QString("PIDInfo(%1) Warning: ").arg(dvb_dev_num) -#define LOC_ERR QString("PIDInfo(%1) Error: ").arg(dvb_dev_num) +#define LOC QString("PIDInfo(%1): ").arg(dvb_dev) +#define LOC_WARN QString("PIDInfo(%1) Warning: ").arg(dvb_dev) +#define LOC_ERR QString("PIDInfo(%1) Error: ").arg(dvb_dev) -bool PIDInfo::Open(uint dvb_dev_num, bool use_section_reader) +bool PIDInfo::Open(const QString &dvb_dev, bool use_section_reader) { if (filter_fd >= 0) { @@ -814,7 +813,7 @@ filter_fd = -1; } - QString demux_fn = CardUtil::GetDeviceName(DVB_DEV_DEMUX, dvb_dev_num); + QString demux_fn = CardUtil::GetDeviceName(DVB_DEV_DEMUX, dvb_dev); VERBOSE(VB_RECORD, LOC + QString("Opening filter for pid 0x%1") .arg(_pid, 0, 16)); @@ -909,7 +908,7 @@ return true; } -bool PIDInfo::Close(uint dvb_dev_num) +bool PIDInfo::Close(const QString &dvb_dev) { VERBOSE(VB_RECORD, LOC + QString("Closing filter for pid 0x%1").arg(_pid, 0, 16)); Index: libs/libmythtv/tv_rec.cpp =================================================================== --- libs/libmythtv/tv_rec.cpp (revision 16990) +++ libs/libmythtv/tv_rec.cpp (working copy) @@ -142,7 +142,7 @@ if (genOpt.cardtype == "DVB") { #ifdef USING_DVB - channel = new DVBChannel(genOpt.videodev.toInt(), this); + channel = new DVBChannel(genOpt.videodev, this); if (!channel->Open()) return false; GetDVBChannel()->SetSlowTuning(dvbOpt.dvb_tuning_delay);