From 80817116bafde29df370b519b3485c416c37564e Mon Sep 17 00:00:00 2001 From: Lars Hanisch Date: Fri, 30 Oct 2015 00:43:25 +0100 Subject: adjust for vdr 2.3.1 --- dynamicdevice.c | 2 + dynamicdevice.h | 2 + dynamite.c | 2 +- patches/vdr-2.3.1-dynamite.diff | 803 ++++++++++++++++++++++++++++++++++++++++ status.c | 24 +- udev.c | 12 +- 6 files changed, 835 insertions(+), 10 deletions(-) create mode 100644 patches/vdr-2.3.1-dynamite.diff diff --git a/dynamicdevice.c b/dynamicdevice.c index 8106e36..8239bac 100644 --- a/dynamicdevice.c +++ b/dynamicdevice.c @@ -817,12 +817,14 @@ void cDynamicDevice::SetVideoFormat(bool VideoFormat16_9) cDevice::SetVideoFormat(VideoFormat16_9); } +#if VDRVERSNUM < 20300 || defined(DEPRECATED_VIDEOSYSTEM) eVideoSystem cDynamicDevice::GetVideoSystem(void) { if (subDevice) return subDevice->GetVideoSystem(); return cDevice::GetVideoSystem(); } +#endif void cDynamicDevice::GetVideoSize(int &Width, int &Height, double &VideoAspect) { diff --git a/dynamicdevice.h b/dynamicdevice.h index a7969bb..368acc7 100644 --- a/dynamicdevice.h +++ b/dynamicdevice.h @@ -131,7 +131,9 @@ public: virtual uchar *GrabImage(int &Size, bool Jpeg = true, int Quality = -1, int SizeX = -1, int SizeY = -1); virtual void SetVideoDisplayFormat(eVideoDisplayFormat VideoDisplayFormat); virtual void SetVideoFormat(bool VideoFormat16_9); +#if VDRVERSNUM < 20300 || defined(DEPRECATED_VIDEOSYSTEM) virtual eVideoSystem GetVideoSystem(void); +#endif virtual void GetVideoSize(int &Width, int &Height, double &VideoAspect); virtual void GetOsdSize(int &Width, int &Height, double &PixelAspect); protected: diff --git a/dynamite.c b/dynamite.c index 00fcc65..6f6ae0a 100644 --- a/dynamite.c +++ b/dynamite.c @@ -11,7 +11,7 @@ #include "monitor.h" #include "status.h" -static const char *VERSION = "0.2.1"; +static const char *VERSION = "0.3.0"; static const char *DESCRIPTION = tr("attach/detach devices on the fly"); static const char *MAINMENUENTRY = NULL; diff --git a/patches/vdr-2.3.1-dynamite.diff b/patches/vdr-2.3.1-dynamite.diff new file mode 100644 index 0000000..9ba6b99 --- /dev/null +++ b/patches/vdr-2.3.1-dynamite.diff @@ -0,0 +1,803 @@ +diff --git a/ci.h b/ci.h +index a420015..0caa51a 100644 +--- a/ci.h ++++ b/ci.h +@@ -116,6 +116,8 @@ public: + cCiAdapter(void); + virtual ~cCiAdapter(); + ///< The derived class must call Cancel(3) in its destructor. ++ virtual bool SetIdle(bool Idle, bool TestOnly) { return false; } ++ virtual bool IsIdle(void) const { return false; } + }; + + class cTPDU; +diff --git a/device.c b/device.c +index 174281f..1296a08 100644 +--- a/device.c ++++ b/device.c +@@ -70,12 +70,22 @@ int cDevice::currentChannel = 1; + cDevice *cDevice::device[MAXDEVICES] = { NULL }; + cDevice *cDevice::primaryDevice = NULL; + cList cDevice::deviceHooks; ++cDevice *cDevice::nextParentDevice = NULL; + +-cDevice::cDevice(void) ++cDevice::cDevice(cDevice *ParentDevice) + :patPmtParser(true) +-{ +- cardIndex = nextCardIndex++; +- dsyslog("new device number %d", CardIndex() + 1); ++,isIdle(false) ++,parentDevice(ParentDevice) ++,subDevice(NULL) ++{ ++ if (!ParentDevice) ++ parentDevice = nextParentDevice; ++ cDevice::nextParentDevice = NULL; ++ if (parentDevice) ++ cardIndex = parentDevice->cardIndex; ++ else ++ cardIndex = nextCardIndex++; ++ dsyslog("new %sdevice number %d", parentDevice ? "sub-" : "", CardIndex() + 1); + + SetDescription("device %d receiver", CardIndex() + 1); + +@@ -107,10 +117,14 @@ cDevice::cDevice(void) + for (int i = 0; i < MAXRECEIVERS; i++) + receiver[i] = NULL; + +- if (numDevices < MAXDEVICES) +- device[numDevices++] = this; ++ if (!parentDevice) { ++ if (numDevices < MAXDEVICES) ++ device[numDevices++] = this; ++ else ++ esyslog("ERROR: too many devices or \"dynamite\"-unpatched device creator!"); ++ } + else +- esyslog("ERROR: too many devices!"); ++ parentDevice->subDevice = this; + } + + cDevice::~cDevice() +@@ -121,6 +135,29 @@ cDevice::~cDevice() + delete dvbSubtitleConverter; + if (this == primaryDevice) + primaryDevice = NULL; ++ if (parentDevice && (parentDevice->subDevice == this)) ++ parentDevice->subDevice = NULL; ++} ++ ++bool cDevice::SetIdle(bool Idle) ++{ ++ if (parentDevice) ++ return parentDevice->SetIdle(Idle); ++ if (isIdle == Idle) ++ return true; ++ if (Receiving(false)) ++ return false; ++ if (Idle) { ++ Detach(player); ++ DetachAllReceivers(); ++ } ++ if (!SetIdleDevice(Idle, true)) ++ return false; ++ isIdle = Idle; ++ if (SetIdleDevice(Idle, false)) ++ return true; ++ isIdle = !Idle; ++ return false; + } + + bool cDevice::WaitForAllDevicesReady(int Timeout) +@@ -159,6 +196,8 @@ int cDevice::NextCardIndex(int n) + + int cDevice::DeviceNumber(void) const + { ++ if (parentDevice) ++ return parentDevice->DeviceNumber(); + for (int i = 0; i < numDevices; i++) { + if (device[i] == this) + return i; +@@ -359,6 +398,8 @@ bool cDevice::HasCi(void) + + void cDevice::SetCamSlot(cCamSlot *CamSlot) + { ++ if (parentDevice) ++ return parentDevice->SetCamSlot(CamSlot); + LOCK_THREAD; + camSlot = CamSlot; + } +@@ -566,6 +607,10 @@ void cDevice::DelLivePids(void) + + void cDevice::StartSectionHandler(void) + { ++ if (parentDevice) { ++ parentDevice->StartSectionHandler(); ++ return; ++ } + if (!sectionHandler) { + sectionHandler = new cSectionHandler(this); + AttachFilter(eitFilter = new cEitFilter); +@@ -577,6 +622,10 @@ void cDevice::StartSectionHandler(void) + + void cDevice::StopSectionHandler(void) + { ++ if (parentDevice) { ++ parentDevice->StopSectionHandler(); ++ return; ++ } + if (sectionHandler) { + delete nitFilter; + delete sdtFilter; +@@ -608,12 +657,17 @@ void cDevice::CloseFilter(int Handle) + + void cDevice::AttachFilter(cFilter *Filter) + { ++ if (parentDevice) ++ return parentDevice->AttachFilter(Filter); ++ SetIdle(false); + if (sectionHandler) + sectionHandler->Attach(Filter); + } + + void cDevice::Detach(cFilter *Filter) + { ++ if (parentDevice) ++ return parentDevice->Detach(Filter); + if (sectionHandler) + sectionHandler->Detach(Filter); + } +@@ -783,6 +837,7 @@ eSetChannelResult cDevice::SetChannel(const cChannel *Channel, bool LiveView) + sectionHandler->SetStatus(false); + sectionHandler->SetChannel(NULL); + } ++ SetIdle(false); + // Tell the camSlot about the channel switch and add all PIDs of this + // channel to it, for possible later decryption: + if (camSlot) +@@ -830,19 +885,27 @@ void cDevice::ForceTransferMode(void) + { + if (!cTransferControl::ReceiverDevice()) { + LOCK_CHANNELS_READ; +- if (const cChannel *Channel = Channels->GetByNumber(CurrentChannel())) ++ if (const cChannel *Channel = Channels->GetByNumber(CurrentChannel())) { ++ SetIdle(false); + SetChannelDevice(Channel, false); // this implicitly starts Transfer Mode ++ } + } + } + + int cDevice::Occupied(void) const + { ++ if (parentDevice) ++ return parentDevice->Occupied(); + int Seconds = occupiedTimeout - time(NULL); + return Seconds > 0 ? Seconds : 0; + } + + void cDevice::SetOccupied(int Seconds) + { ++ if (parentDevice) { ++ parentDevice->SetOccupied(Seconds); ++ return; ++ } + if (Seconds >= 0) + occupiedTimeout = time(NULL) + min(Seconds, MAXOCCUPIEDTIMEOUT); + } +@@ -1225,7 +1288,10 @@ bool cDevice::Transferring(void) const + + bool cDevice::AttachPlayer(cPlayer *Player) + { ++ if (parentDevice) ++ return parentDevice->AttachPlayer(Player); + if (CanReplay()) { ++ SetIdle(false); + if (player) + Detach(player); + DELETENULL(liveSubtitle); +@@ -1244,6 +1310,8 @@ bool cDevice::AttachPlayer(cPlayer *Player) + + void cDevice::Detach(cPlayer *Player) + { ++ if (parentDevice) ++ return parentDevice->Detach(Player); + if (Player && player == Player) { + cPlayer *p = player; + player = NULL; // avoids recursive calls to Detach() +@@ -1263,6 +1331,8 @@ void cDevice::Detach(cPlayer *Player) + + void cDevice::StopReplay(void) + { ++ if (parentDevice) ++ return parentDevice->StopReplay(); + if (player) { + Detach(player); + if (IsPrimaryDevice()) +@@ -1543,6 +1613,8 @@ int cDevice::PlayTs(const uchar *Data, int Length, bool VideoOnly) + + int cDevice::Priority(void) const + { ++ if (parentDevice) ++ return parentDevice->Priority(); + int priority = IDLEPRIORITY; + if (IsPrimaryDevice() && !Replaying() && HasProgramme()) + priority = TRANSFERPRIORITY; // we use the same value here, no matter whether it's actual Transfer Mode or real live viewing +@@ -1561,6 +1633,8 @@ bool cDevice::Ready(void) + + bool cDevice::Receiving(bool Dummy) const + { ++ if (parentDevice) ++ return parentDevice->Receiving(Dummy); + cMutexLock MutexLock(&mutexReceiver); + for (int i = 0; i < MAXRECEIVERS; i++) { + if (receiver[i]) +@@ -1642,10 +1716,13 @@ bool cDevice::GetTSPacket(uchar *&Data) + + bool cDevice::AttachReceiver(cReceiver *Receiver) + { ++ if (parentDevice) ++ return parentDevice->AttachReceiver(Receiver); + if (!Receiver) + return false; + if (Receiver->device == this) + return true; ++ SetIdle(false); + // activate the following line if you need it - actually the driver should be fixed! + //#define WAIT_FOR_TUNER_LOCK + #ifdef WAIT_FOR_TUNER_LOCK +@@ -1684,6 +1761,8 @@ bool cDevice::AttachReceiver(cReceiver *Receiver) + + void cDevice::Detach(cReceiver *Receiver) + { ++ if (parentDevice) ++ return parentDevice->Detach(Receiver); + if (!Receiver || Receiver->device != this) + return; + bool receiversLeft = false; +@@ -1714,6 +1793,8 @@ void cDevice::Detach(cReceiver *Receiver) + + void cDevice::DetachAll(int Pid) + { ++ if (parentDevice) ++ return parentDevice->DetachAll(Pid); + if (Pid) { + cMutexLock MutexLock(&mutexReceiver); + for (int i = 0; i < MAXRECEIVERS; i++) { +@@ -1806,3 +1887,25 @@ void cTSBuffer::Skip(int Count) + ringBuffer->Del(Count); + delivered = false; + } ++ ++// --- cDynamicDeviceProbe ------------------------------------------------------- ++ ++cList DynamicDeviceProbes; ++ ++cList cDynamicDeviceProbe::commandQueue; ++ ++void cDynamicDeviceProbe::QueueDynamicDeviceCommand(eDynamicDeviceProbeCommand Cmd, const char *DevPath) ++{ ++ if (DevPath) ++ commandQueue.Add(new cDynamicDeviceProbeItem(Cmd, new cString(DevPath))); ++} ++ ++cDynamicDeviceProbe::cDynamicDeviceProbe(void) ++{ ++ DynamicDeviceProbes.Add(this); ++} ++ ++cDynamicDeviceProbe::~cDynamicDeviceProbe() ++{ ++ DynamicDeviceProbes.Del(this, false); ++} +diff --git a/device.h b/device.h +index 31ee303..41d66f8 100644 +--- a/device.h ++++ b/device.h +@@ -174,7 +174,6 @@ private: + static int nextCardIndex; + int cardIndex; + protected: +- cDevice(void); + virtual ~cDevice(); + virtual bool Ready(void); + ///< Returns true if this device is ready. Devices with conditional +@@ -201,9 +200,6 @@ protected: + ///< A derived class must call the MakePrimaryDevice() function of its + ///< base class. + public: +- bool IsPrimaryDevice(void) const { return this == primaryDevice && HasDecoder(); } +- int CardIndex(void) const { return cardIndex; } +- ///< Returns the card index of this device (0 ... MAXDEVICES - 1). + int DeviceNumber(void) const; + ///< Returns the number of this device (0 ... numDevices - 1). + virtual cString DeviceType(void) const; +@@ -433,9 +429,6 @@ public: + ///< shall check whether the channel can be decrypted. + void SetCamSlot(cCamSlot *CamSlot); + ///< Sets the given CamSlot to be used with this device. +- cCamSlot *CamSlot(void) const { return camSlot; } +- ///< Returns the CAM slot that is currently used with this device, +- ///< or NULL if no CAM slot is in use. + + // Image Grab facilities + +@@ -604,9 +597,6 @@ private: + cTsToPes tsToPesSubtitle; + bool isPlayingVideo; + protected: +- const cPatPmtParser *PatPmtParser(void) const { return &patPmtParser; } +- ///< Returns a pointer to the patPmtParser, so that a derived device +- ///< can use the stream information from it. + virtual bool CanReplay(void) const; + ///< Returns true if this device can currently start a replay session. + virtual bool SetPlayMode(ePlayMode PlayMode); +@@ -821,6 +811,38 @@ public: + ///< Detaches all receivers from this device for this pid. + virtual void DetachAllReceivers(void); + ///< Detaches all receivers from this device. ++ ++// --- dynamite subdevice patch start --- ++ friend class cDynamicDevice; ++private: ++ static cDevice *nextParentDevice; ++ ///< Holds the parent device for the next subdevice ++ ///< so the dynamite-plugin can work with unpatched plugins ++ bool isIdle; ++protected: ++ cDevice *parentDevice; ++ cDevice *subDevice; ++ cDevice(cDevice *ParentDevice = NULL); ++ const cPatPmtParser *PatPmtParser(void) const { if (parentDevice) return parentDevice->PatPmtParser(); return &patPmtParser; } ++ ///< Returns a pointer to the patPmtParser, so that a derived device ++ ///< can use the stream information from it. ++public: ++ bool IsPrimaryDevice(void) const { if (parentDevice) return parentDevice->IsPrimaryDevice(); return this == primaryDevice && HasDecoder(); } ++ int CardIndex(void) const { if (parentDevice) return parentDevice->cardIndex; return cardIndex; } ++ ///< Returns the card index of this device (0 ... MAXDEVICES - 1). ++ cCamSlot *CamSlot(void) const { if (parentDevice) return parentDevice->CamSlot(); return camSlot; } ++ ///< Returns the CAM slot that is currently used with this device, ++ ///< or NULL if no CAM slot is in use. ++ bool IsSubDevice(void) const { return (parentDevice != NULL); } ++ bool HasSubDevice(void) const { return (subDevice != NULL); } ++ cDevice *SubDevice(void) const { return subDevice; } ++ bool IsIdle(void) const { if (parentDevice) return parentDevice->IsIdle(); return isIdle; } ++ bool SetIdle(bool Idle); ++ virtual bool SetIdleDevice(bool Idle, bool TestOnly) { return false; } ++ ///< Called by SetIdle ++ ///< if TestOnly, don't do anything, just return, if the device ++ ///< can be set to the new idle state ++ // --- dynamite subdevice patch end --- + }; + + /// Derived cDevice classes that can receive channels will have to provide +@@ -857,4 +879,47 @@ public: + ///< to Get(). + }; + ++/// A plugin that want to create devices handled by the dynamite-plugin needs to create ++/// a cDynamicDeviceProbe derived object on the heap in order to have its Probe() ++/// function called, where it can actually create the appropriate device. ++/// The cDynamicDeviceProbe object must be created in the plugin's constructor, ++/// and deleted in its destructor. ++/// The "DevPath" hasn't to be a physical device or a path in the filesystem. ++/// It can be any string a plugin may react on. ++ ++#define __DYNAMIC_DEVICE_PROBE ++ ++enum eDynamicDeviceProbeCommand { ddpcAttach, ddpcDetach, ddpcService }; ++ ++class cDynamicDeviceProbe : public cListObject { ++ friend class cDynamicDevice; ++private: ++ class cDynamicDeviceProbeItem : public cListObject { ++ public: ++ eDynamicDeviceProbeCommand cmd; ++ cString *devpath; ++ cDynamicDeviceProbeItem(eDynamicDeviceProbeCommand Cmd, cString *DevPath):cmd(Cmd),devpath(DevPath) {} ++ virtual ~cDynamicDeviceProbeItem() { if (devpath) delete devpath; } ++ }; ++ static cList commandQueue; ++ ///< A list where all attach/detach commands are queued ++ ///< so they can be processed in the MainThreadHook of ++ ///< the dynamite plugin. ++public: ++ static void QueueDynamicDeviceCommand(eDynamicDeviceProbeCommand Cmd, const char *DevPath); ++ ///< Plugins which support cDynamicDeviceProbe must use this function ++ ///< to queue the devices they normally create in their Initialize method. ++ ///< These devices are created as subdevices in the Start-method of the dynamite-plugin. ++ cDynamicDeviceProbe(void); ++ virtual ~cDynamicDeviceProbe(); ++ virtual cDevice *Attach(cDevice *ParentDevice, const char *DevPath) = 0; ++ ///< Probes for a device at the given device-path like /dev/dvb/adapter0/frontend0 ++ ///< or /dev/video0 etc. and creates the appropriate ++ ///< object derived from cDevice if applicable. ++ ///< Returns the device that has been created or NULL if not. ++ ///< The dynamite-plugin will delete the device if it is detached. ++ }; ++ ++extern cList DynamicDeviceProbes; ++ + #endif //__DEVICE_H +diff --git a/dvbci.c b/dvbci.c +index afe3b31..10a4614 100644 +--- a/dvbci.c ++++ b/dvbci.c +@@ -10,15 +10,18 @@ + #include "dvbci.h" + #include + #include +-#include "device.h" ++#include "dvbdevice.h" + + // --- cDvbCiAdapter --------------------------------------------------------- + +-cDvbCiAdapter::cDvbCiAdapter(cDevice *Device, int Fd) ++cDvbCiAdapter::cDvbCiAdapter(cDevice *Device, int Fd, int Adapter, int Frontend) + { + device = Device; + SetDescription("device %d CI adapter", device->DeviceNumber()); + fd = Fd; ++ adapter = Adapter; ++ frontend = Frontend; ++ idle = false; + ca_caps_t Caps; + if (ioctl(fd, CA_GET_CAP, &Caps) == 0) { + if ((Caps.slot_type & CA_CI_LINK) != 0) { +@@ -41,10 +44,44 @@ cDvbCiAdapter::cDvbCiAdapter(cDevice *Device, int Fd) + cDvbCiAdapter::~cDvbCiAdapter() + { + Cancel(3); ++ if (device->IsSubDevice() || device->HasSubDevice()) ++ CloseCa(); ++} ++ ++bool cDvbCiAdapter::OpenCa(void) ++{ ++ if (fd >= 0) ++ return true; ++ fd = cDvbDevice::DvbOpen(DEV_DVB_CA, adapter, frontend, O_RDWR); ++ return (fd >= 0); ++} ++ ++void cDvbCiAdapter::CloseCa(void) ++{ ++ if (fd < 0) ++ return; ++ close(fd); ++ fd = -1; ++} ++ ++bool cDvbCiAdapter::SetIdle(bool Idle, bool TestOnly) ++{ ++ if ((adapter < 0) || (frontend < 0)) ++ return false; ++ if (TestOnly || (idle == Idle)) ++ return true; ++ if (Idle) ++ CloseCa(); ++ else ++ OpenCa(); ++ idle = Idle; ++ return true; + } + + int cDvbCiAdapter::Read(uint8_t *Buffer, int MaxLength) + { ++ if (idle || (fd < 0)) ++ return 0; + if (Buffer && MaxLength > 0) { + struct pollfd pfd[1]; + pfd[0].fd = fd; +@@ -61,6 +98,8 @@ int cDvbCiAdapter::Read(uint8_t *Buffer, int MaxLength) + + void cDvbCiAdapter::Write(const uint8_t *Buffer, int Length) + { ++ if (idle || (fd < 0)) ++ return; + if (Buffer && Length > 0) { + if (safe_write(fd, Buffer, Length) != Length) + esyslog("ERROR: can't write to CI adapter on device %d: %m", device->DeviceNumber()); +@@ -69,6 +108,8 @@ void cDvbCiAdapter::Write(const uint8_t *Buffer, int Length) + + bool cDvbCiAdapter::Reset(int Slot) + { ++ if (idle || (fd < 0)) ++ return false; + if (ioctl(fd, CA_RESET, 1 << Slot) != -1) + return true; + else +@@ -78,6 +119,8 @@ bool cDvbCiAdapter::Reset(int Slot) + + eModuleStatus cDvbCiAdapter::ModuleStatus(int Slot) + { ++ if (idle || (fd < 0)) ++ return msNone; + ca_slot_info_t sinfo; + sinfo.num = Slot; + if (ioctl(fd, CA_GET_SLOT_INFO, &sinfo) != -1) { +@@ -99,10 +142,10 @@ bool cDvbCiAdapter::Assign(cDevice *Device, bool Query) + return true; + } + +-cDvbCiAdapter *cDvbCiAdapter::CreateCiAdapter(cDevice *Device, int Fd) ++cDvbCiAdapter *cDvbCiAdapter::CreateCiAdapter(cDevice *Device, int Fd, int Adapter, int Frontend) + { + // TODO check whether a CI is actually present? + if (Device) +- return new cDvbCiAdapter(Device, Fd); ++ return new cDvbCiAdapter(Device, Fd, Adapter, Frontend); + return NULL; + } +diff --git a/dvbci.h b/dvbci.h +index 4e6d24b..c8d20e2 100644 +--- a/dvbci.h ++++ b/dvbci.h +@@ -16,16 +16,24 @@ class cDvbCiAdapter : public cCiAdapter { + private: + cDevice *device; + int fd; ++ int adapter; ++ int frontend; ++ bool idle; ++ ++ bool OpenCa(void); ++ void CloseCa(void); + protected: + virtual int Read(uint8_t *Buffer, int MaxLength); + virtual void Write(const uint8_t *Buffer, int Length); + virtual bool Reset(int Slot); + virtual eModuleStatus ModuleStatus(int Slot); + virtual bool Assign(cDevice *Device, bool Query = false); +- cDvbCiAdapter(cDevice *Device, int Fd); ++ cDvbCiAdapter(cDevice *Device, int Fd, int Adapter = -1, int Frontend = -1); + public: + virtual ~cDvbCiAdapter(); +- static cDvbCiAdapter *CreateCiAdapter(cDevice *Device, int Fd); ++ virtual bool SetIdle(bool Idle, bool TestOnly); ++ virtual bool IsIdle(void) const { return idle; } ++ static cDvbCiAdapter *CreateCiAdapter(cDevice *Device, int Fd, int Adapter = -1, int Frontend = -1); + }; + + #endif //__DVBCI_H +diff --git a/dvbdevice.c b/dvbdevice.c +index 63af52e..fb8fbae 100644 +--- a/dvbdevice.c ++++ b/dvbdevice.c +@@ -303,7 +303,7 @@ private: + enum eTunerStatus { tsIdle, tsSet, tsPositioning, tsTuned, tsLocked }; + int frontendType; + const cDvbDevice *device; +- int fd_frontend; ++ mutable int fd_frontend; + int adapter, frontend; + uint32_t subsystemId; + int tuneTimeout; +@@ -317,7 +317,7 @@ private: + const cScr *scr; + bool lnbPowerTurnedOn; + eTunerStatus tunerStatus; +- cMutex mutex; ++ mutable cMutex mutex; + cCondVar locked; + cCondVar newSet; + cDvbTuner *bondedTuner; +@@ -333,6 +333,10 @@ private: + void ResetToneAndVoltage(void); + bool SetFrontend(void); + virtual void Action(void); ++ ++ mutable bool isIdle; ++ bool OpenFrontend(void) const; ++ bool CloseFrontend(void); + public: + cDvbTuner(const cDvbDevice *Device, int Fd_Frontend, int Adapter, int Frontend); + virtual ~cDvbTuner(); +@@ -348,6 +352,8 @@ public: + const cPositioner *Positioner(void) const { return positioner; } + int GetSignalStrength(void) const; + int GetSignalQuality(void) const; ++ bool SetIdle(bool Idle); ++ bool IsIdle(void) const { return isIdle; } + }; + + cMutex cDvbTuner::bondMutex; +@@ -372,6 +378,7 @@ cDvbTuner::cDvbTuner(const cDvbDevice *Device, int Fd_Frontend, int Adapter, int + tunerStatus = tsIdle; + bondedTuner = NULL; + bondedMaster = false; ++ isIdle = false; + SetDescription("frontend %d/%d tuner", adapter, frontend); + Start(); + } +@@ -389,6 +396,8 @@ cDvbTuner::~cDvbTuner() + ExecuteDiseqc(lastDiseqc, &Frequency); + } + */ ++ if (device && device->IsSubDevice()) ++ CloseFrontend(); + } + + bool cDvbTuner::Bond(cDvbTuner *Tuner) +@@ -534,6 +543,8 @@ bool cDvbTuner::Locked(int TimeoutMs) + + void cDvbTuner::ClearEventQueue(void) const + { ++ if (!OpenFrontend()) ++ return; + cPoller Poller(fd_frontend); + if (Poller.Poll(TUNER_POLL_TIMEOUT)) { + dvb_frontend_event Event; +@@ -777,6 +788,8 @@ static int GetRequiredDeliverySystem(const cChannel *Channel, const cDvbTranspon + + bool cDvbTuner::SetFrontend(void) + { ++ if (!OpenFrontend()) ++ return false; + #define MAXFRONTENDCMDS 16 + #define SETCMD(c, d) { Frontend[CmdSeq.num].cmd = (c);\ + Frontend[CmdSeq.num].u.data = (d);\ +@@ -929,9 +942,11 @@ void cDvbTuner::Action(void) + bool LostLock = false; + fe_status_t Status = (fe_status_t)0; + while (Running()) { +- fe_status_t NewStatus; +- if (GetFrontendStatus(NewStatus)) +- Status = NewStatus; ++ if (!isIdle) { ++ fe_status_t NewStatus; ++ if (GetFrontendStatus(NewStatus)) ++ Status = NewStatus; ++ } + cMutexLock MutexLock(&mutex); + int WaitTime = 1000; + switch (tunerStatus) { +@@ -1001,6 +1016,40 @@ void cDvbTuner::Action(void) + } + } + ++bool cDvbTuner::SetIdle(bool Idle) ++{ ++ if (isIdle == Idle) ++ return true; ++ isIdle = Idle; ++ if (Idle) ++ return CloseFrontend(); ++ return OpenFrontend(); ++} ++ ++bool cDvbTuner::OpenFrontend(void) const ++{ ++ if (fd_frontend >= 0) ++ return true; ++ cMutexLock MutexLock(&mutex); ++ fd_frontend = cDvbDevice::DvbOpen(DEV_DVB_FRONTEND, adapter, frontend, O_RDWR | O_NONBLOCK); ++ if (fd_frontend < 0) ++ return false; ++ isIdle = false; ++ return true; ++} ++ ++bool cDvbTuner::CloseFrontend(void) ++{ ++ if (fd_frontend < 0) ++ return true; ++ cMutexLock MutexLock(&mutex); ++ tunerStatus = tsIdle; ++ newSet.Broadcast(); ++ close(fd_frontend); ++ fd_frontend = -1; ++ return true; ++} ++ + // --- cDvbSourceParam ------------------------------------------------------- + + class cDvbSourceParam : public cSourceParam { +@@ -1090,7 +1139,8 @@ const char *DeliverySystemNames[] = { + NULL + }; + +-cDvbDevice::cDvbDevice(int Adapter, int Frontend) ++cDvbDevice::cDvbDevice(int Adapter, int Frontend, cDevice *ParentDevice) ++:cDevice(ParentDevice) + { + adapter = Adapter; + frontend = Frontend; +@@ -1110,7 +1160,7 @@ cDvbDevice::cDvbDevice(int Adapter, int Frontend) + + fd_ca = DvbOpen(DEV_DVB_CA, adapter, frontend, O_RDWR); + if (fd_ca >= 0) +- ciAdapter = cDvbCiAdapter::CreateCiAdapter(this, fd_ca); ++ ciAdapter = cDvbCiAdapter::CreateCiAdapter(parentDevice ? parentDevice : this, fd_ca, adapter, frontend); + + // The DVR device (will be opened and closed as needed): + +@@ -1350,7 +1400,11 @@ bool cDvbDevice::BondDevices(const char *Bondings) + if (d >= 0) { + int ErrorDevice = 0; + if (cDevice *Device1 = cDevice::GetDevice(i)) { ++ if (Device1->HasSubDevice()) ++ Device1 = Device1->SubDevice(); + if (cDevice *Device2 = cDevice::GetDevice(d)) { ++ if (Device2->HasSubDevice()) ++ Device2 = Device2->SubDevice(); + if (cDvbDevice *DvbDevice1 = dynamic_cast(Device1)) { + if (cDvbDevice *DvbDevice2 = dynamic_cast(Device2)) { + if (!DvbDevice1->Bond(DvbDevice2)) +@@ -1384,7 +1438,10 @@ bool cDvbDevice::BondDevices(const char *Bondings) + void cDvbDevice::UnBondDevices(void) + { + for (int i = 0; i < cDevice::NumDevices(); i++) { +- if (cDvbDevice *d = dynamic_cast(cDevice::GetDevice(i))) ++ cDevice *dev = cDevice::GetDevice(i); ++ if (dev && dev->HasSubDevice()) ++ dev = dev->SubDevice(); ++ if (cDvbDevice *d = dynamic_cast(dev)) + d->UnBond(); + } + } +@@ -1438,6 +1495,26 @@ bool cDvbDevice::BondingOk(const cChannel *Channel, bool ConsiderOccupied) const + return true; + } + ++bool cDvbDevice::SetIdleDevice(bool Idle, bool TestOnly) ++{ ++ if (TestOnly) { ++ if (ciAdapter) ++ return ciAdapter->SetIdle(Idle, true); ++ return true; ++ } ++ if (!dvbTuner->SetIdle(Idle)) ++ return false; ++ if (ciAdapter && !ciAdapter->SetIdle(Idle, false)) { ++ dvbTuner->SetIdle(!Idle); ++ return false; ++ } ++ if (Idle) ++ StopSectionHandler(); ++ else ++ StartSectionHandler(); ++ return true; ++} ++ + bool cDvbDevice::HasCi(void) + { + return ciAdapter; +@@ -1607,7 +1684,7 @@ bool cDvbDevice::ProvidesChannel(const cChannel *Channel, int Priority, bool *Ne + + bool cDvbDevice::ProvidesEIT(void) const + { +- return dvbTuner != NULL; ++ return !IsIdle() && (dvbTuner != NULL) && !dvbTuner->IsIdle() && ((ciAdapter == NULL) || !ciAdapter->IsIdle()); + } + + int cDvbDevice::NumProvidedSystems(void) const +diff --git a/dvbdevice.h b/dvbdevice.h +index 5ae4952..1fc0f53 100644 +--- a/dvbdevice.h ++++ b/dvbdevice.h +@@ -165,7 +165,7 @@ class cDvbTuner; + /// The cDvbDevice implements a DVB device which can be accessed through the Linux DVB driver API. + + class cDvbDevice : public cDevice { +-protected: ++public: + static cString DvbName(const char *Name, int Adapter, int Frontend); + static int DvbOpen(const char *Name, int Adapter, int Frontend, int Mode, bool ReportError = false); + private: +@@ -192,12 +192,14 @@ private: + mutable bool needsDetachBondedReceivers; + bool QueryDeliverySystems(int fd_frontend); + public: +- cDvbDevice(int Adapter, int Frontend); ++ cDvbDevice(int Adapter, int Frontend, cDevice *ParentDevice = NULL); + virtual ~cDvbDevice(); + int Adapter(void) const { return adapter; } + int Frontend(void) const { return frontend; } + virtual cString DeviceType(void) const; + virtual cString DeviceName(void) const; ++ virtual bool SetIdleDevice(bool Idle, bool TestOnly); ++ + static bool BondDevices(const char *Bondings); + ///< Bonds the devices as defined in the given Bondings string. + ///< A bonding is a sequence of device numbers (starting at 1), diff --git a/status.c b/status.c index d590d59..45db455 100644 --- a/status.c +++ b/status.c @@ -44,13 +44,25 @@ void cDynamiteStatus::Init(void) if (isnumber(cid)) // for compatibility with old setup.conf files startupChannel = atoi(cid); else { - if (cChannel *Channel = Channels.GetByChannelID(tChannelID::FromString(cid))) { +#if VDRVERSNUM > 20300 + LOCK_CHANNELS_READ; + const cChannels *vdrchannels = Channels; +#else + cChannels *vdrchannels = &Channels; +#endif + if (const cChannel *Channel = vdrchannels->GetByChannelID(tChannelID::FromString(cid))) { status = new cDynamiteStatus(Channel->Number()); return; } } } - if (cChannel *Channel = Channels.GetByNumber(startupChannel)) +#if VDRVERSNUM > 20300 + LOCK_CHANNELS_READ; + const cChannels *vdrchannels = Channels; +#else + cChannels *vdrchannels = &Channels; +#endif + if (const cChannel *Channel = vdrchannels->GetByNumber(startupChannel)) status = new cDynamiteStatus(Channel->Number()); } @@ -71,6 +83,12 @@ void cDynamiteStatus::SetStartupChannel(void) return; } isyslog("dynamite: new device attached, retry switching to startup channel %d", status->startupChannel); - if (!Channels.SwitchTo(status->startupChannel)) +#if VDRVERSNUM > 20300 + LOCK_CHANNELS_READ; + const cChannels *vdrchannels = Channels; +#else + cChannels *vdrchannels = &Channels; +#endif + if (!vdrchannels->SwitchTo(status->startupChannel)) status->switchCount--; } diff --git a/udev.c b/udev.c index 254ad63..d0fe736 100644 --- a/udev.c +++ b/udev.c @@ -79,14 +79,14 @@ dynamite::cUdevListEntry *dynamite::cUdevDevice::GetDevlinksList(void) const const char *dynamite::cUdevDevice::GetDevnode(void) const { if (device == NULL) - return false; + return NULL; return udev_device_get_devnode(device); } const char *dynamite::cUdevDevice::GetDevpath(void) const { if (device == NULL) - return false; + return NULL; return udev_device_get_devpath(device); } @@ -103,28 +103,28 @@ dynamite::cUdevDevice *dynamite::cUdevDevice::GetParent(void) const const char *dynamite::cUdevDevice::GetPropertyValue(const char *Key) const { if (device == NULL) - return false; + return NULL; return udev_device_get_property_value(device, Key); } const char *dynamite::cUdevDevice::GetSubsystem(void) const { if (device == NULL) - return false; + return NULL; return udev_device_get_subsystem(device); } const char *dynamite::cUdevDevice::GetSysname(void) const { if (device == NULL) - return false; + return NULL; return udev_device_get_sysname(device); } const char *dynamite::cUdevDevice::GetSyspath(void) const { if (device == NULL) - return false; + return NULL; return udev_device_get_syspath(device); } -- cgit v1.2.3