adjust to vdr 1.7.31, drop support for older developer versionsv0.1.0

5 files changed, 858 insertions, 70 deletions

diff --git a/HISTORY b/HISTORY
index 48af73e..99f6db4 100644
--- a/HISTORY
+++ b/HISTORY
@@ -264,3 +264,9 @@ VDR Plugin 'dynamite' Revision History
 2012-05-23: Version 0.0.9f
 
 - add udev attribute "dynamite_attach_delay_preopen"
+
+2012-10-04: Version 0.1.0
+
+- adjust to vdr 1.7.31
+- drop support for older developer versions
+- remove LNB_SHARING code
diff --git a/dynamicdevice.c b/dynamicdevice.c
index 3035b72..d0d642e 100644
--- a/dynamicdevice.c
+++ b/dynamicdevice.c
@@ -754,6 +754,13 @@ bool cDynamicDevice::HasDecoder(void) const
   return cDevice::HasDecoder();
 }
 
+cString cDynamicDevice::DeviceType(void) const
+{
+  if (subDevice)
+     return subDevice->DeviceType();
+  return "dyn";
+}
+
 cString cDynamicDevice::DeviceName(void) const
 {
   if (subDevice)
@@ -782,6 +789,13 @@ bool cDynamicDevice::HasCi(void)
   return cDevice::HasCi();
 }
 
+bool cDynamicDevice::HasInternalCam(void)
+{
+  if (subDevice)
+     return subDevice->HasInternalCam();
+  return cDevice::HasInternalCam();
+}
+
 uchar *cDynamicDevice::GrabImage(int &Size, bool Jpeg, int Quality, int SizeX, int SizeY)
 {
   if (subDevice)
@@ -838,6 +852,13 @@ int cDynamicDevice::OpenFilter(u_short Pid, u_char Tid, u_char Mask)
   return cDevice::OpenFilter(Pid, Tid, Mask);
 }
 
+int cDynamicDevice::ReadFilter(int Handle, void *Buffer, size_t Length)
+{
+  if (subDevice)
+     return subDevice->ReadFilter(Handle, Buffer, Length);
+  return cDevice::ReadFilter(Handle, Buffer, Length);
+}
+
 void cDynamicDevice::CloseFilter(int Handle)
 {
   if (subDevice)
@@ -909,33 +930,19 @@ const cChannel *cDynamicDevice::GetCurrentlyTunedTransponder(void) const
   return cDevice::GetCurrentlyTunedTransponder();
 }
 
-
-#if VDRVERSNUM < 10722
-bool cDynamicDevice::IsTunedToTransponder(const cChannel *Channel)
-#else
 bool cDynamicDevice::IsTunedToTransponder(const cChannel *Channel) const
-#endif
 {
   if (!IsIdle() && subDevice)
      return subDevice->IsTunedToTransponder(Channel);
   return cDevice::IsTunedToTransponder(Channel);
 }
 
-#if VDRVERSNUM < 10722
-bool cDynamicDevice::MaySwitchTransponder(void)
-{
-  if (subDevice)
-     return subDevice->MaySwitchTransponder();
-  return cDevice::MaySwitchTransponder();
-}
-#else
 bool cDynamicDevice::MaySwitchTransponder(const cChannel *Channel) const
 {
   if (subDevice)
      return subDevice->MaySwitchTransponder(Channel);
   return cDevice::MaySwitchTransponder(Channel);
 }
-#endif
 
 bool cDynamicDevice::SetChannelDevice(const cChannel *Channel, bool LiveView)
 {
@@ -1209,15 +1216,6 @@ bool cDynamicDevice::GetTSPacket(uchar *&Data)
   return cDevice::GetTSPacket(Data);
 }
 
-#ifdef INTERNAL_CAM_DEVICES_PATCH
-bool cDynamicDevice::HasInternalCam(void)
-{
-  if (subDevice)
-     return subDevice->HasInternalCam();
-  return cDevice::HasInternalCam();
-}
-#endif
-
 #ifdef YAVDR_PATCHES
 //opt-44_rotor.dpatch 
 bool cDynamicDevice::SendDiseqcCmd(dvb_diseqc_master_cmd cmd)
@@ -1227,33 +1225,3 @@ bool cDynamicDevice::SendDiseqcCmd(dvb_diseqc_master_cmd cmd)
   return cDevice::SendDiseqcCmd(cmd);
 }
 #endif
-
-#ifdef LNB_SHARING_VERSION
-void cDynamicDevice::SetLnbNrFromSetup(void)
-{
-  if (subDevice)
-     return subDevice->SetLnbNrFromSetup();
-  cDevice::SetLnbNrFromSetup();
-}
-
-int cDynamicDevice::LnbNr(void) const
-{
-  if (subDevice)
-     return subDevice->LnbNr();
-  return cDevice::LnbNr();
-}
-
-bool cDynamicDevice::IsShareLnb(const cDevice *Device)
-{
-  if (subDevice)
-     return subDevice->IsShareLnb(Device);
-  return cDevice::IsShareLnb(Device);
-}
-
-bool cDynamicDevice::IsLnbConflict(const cChannel *Channel)
-{
-  if (subDevice)
-     return subDevice->IsLnbConflict(Channel);
-  return cDevice::IsLnbConflict(Channel);
-}
-#endif
diff --git a/dynamicdevice.h b/dynamicdevice.h
index 274ba69..b84b1d8 100644
--- a/dynamicdevice.h
+++ b/dynamicdevice.h
@@ -97,6 +97,7 @@ protected:
   virtual bool Ready(void);
   virtual void MakePrimaryDevice(bool On);
 public:
+  virtual cString DeviceType(void) const;
   virtual cString DeviceName(void) const;
   virtual bool HasDecoder(void) const;
   virtual bool AvoidRecording(void) const;
@@ -109,13 +110,8 @@ public:
   virtual int SignalStrength(void) const;
   virtual int SignalQuality(void) const;
   virtual const cChannel *GetCurrentlyTunedTransponder(void) const;
-#if VDRVERSNUM < 10722
-  virtual bool IsTunedToTransponder(const cChannel *Channel);
-  virtual bool MaySwitchTransponder(void);
-#else
   virtual bool IsTunedToTransponder(const cChannel *Channel) const;
   virtual bool MaySwitchTransponder(const cChannel *Channel) const;
-#endif
 protected:
   virtual bool SetChannelDevice(const cChannel *Channel, bool LiveView);
 public:
@@ -125,8 +121,10 @@ protected:
   virtual bool SetPid(cPidHandle *Handle, int Type, bool On);
 public:
   virtual int OpenFilter(u_short Pid, u_char Tid, u_char Mask);
+  virtual int ReadFilter(int Handle, void *Buffer, size_t Length);
   virtual void CloseFilter(int Handle);
   virtual bool HasCi(void);
+  virtual bool HasInternalCam(void);
   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);
@@ -167,22 +165,11 @@ protected:
   virtual bool OpenDvr(void);
   virtual void CloseDvr(void);
   virtual bool GetTSPacket(uchar *&Data);
-  
-#ifdef INTERNAL_CAM_DEVICES_PATCH
-  virtual bool HasInternalCam(void);
-#endif
 
 #ifdef YAVDR_PATCHES
 //opt-44_rotor
   virtual bool SendDiseqcCmd(dvb_diseqc_master_cmd cmd);
 #endif
-
-#ifdef LNB_SHARING_VERSION
-  virtual void SetLnbNrFromSetup(void);
-  virtual int LnbNr(void) const;
-  virtual bool IsShareLnb(const cDevice *Device);
-  virtual bool IsLnbConflict(const cChannel *Channel);
-#endif
   };
 
 #endif //__DYNAMITEDEVICE_H
diff --git a/dynamite.c b/dynamite.c
index 98ff9ed..7ef6494 100644
--- a/dynamite.c
+++ b/dynamite.c
@@ -11,7 +11,7 @@
 #include "monitor.h"
 #include "status.h"
 
-static const char *VERSION        = "0.0.9f";
+static const char *VERSION        = "0.1.0";
 static const char *DESCRIPTION    = tr("attach/detach devices on the fly");
 static const char *MAINMENUENTRY  = NULL;
 
diff --git a/patches/vdr-1.7.31-dynamite-subdevice.patch b/patches/vdr-1.7.31-dynamite-subdevice.patch
new file mode 100644
index 0000000..3afdbbe
--- /dev/null
+++ b/patches/vdr-1.7.31-dynamite-subdevice.patch
@@ -0,0 +1,827 @@
+diff --git a/ci.c b/ci.c
+index ebed320..517b0c5 100644
+--- a/ci.c
++++ b/ci.c
+@@ -1571,6 +1571,8 @@ cCamSlot::cCamSlot(cCiAdapter *CiAdapter)
+ 
+ cCamSlot::~cCamSlot()
+ {
++  if (ciAdapter && ciAdapter->assignedDevice)
++     ciAdapter->assignedDevice->SetCamSlot(NULL);
+   CamSlots.Del(this, false);
+   DeleteAllConnections();
+ }
+diff --git a/ci.h b/ci.h
+index 74e0270..d38e2dd 100644
+--- a/ci.h
++++ b/ci.h
+@@ -115,6 +115,8 @@ public:
+        ///< The derived class must call Cancel(3) in its destructor.
+   virtual bool Ready(void);
+        ///< Returns 'true' if all present CAMs in this adapter are ready.
++  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 aa93a8e..ad14fbd 100644
+--- a/device.c
++++ b/device.c
+@@ -69,12 +69,22 @@ int cDevice::currentChannel = 1;
+ cDevice *cDevice::device[MAXDEVICES] = { NULL };
+ cDevice *cDevice::primaryDevice = NULL;
+ cList<cDeviceHook> cDevice::deviceHooks;
+-
+-cDevice::cDevice(void)
++cDevice *cDevice::nextParentDevice = NULL;
++ 
++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("receiver on device %d", CardIndex() + 1);
+ 
+@@ -105,10 +115,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()
+@@ -117,6 +131,29 @@ cDevice::~cDevice()
+   DetachAllReceivers();
+   delete liveSubtitle;
+   delete dvbSubtitleConverter;
++  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)
+@@ -155,6 +192,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;
+@@ -355,6 +394,8 @@ bool cDevice::HasCi(void)
+ 
+ void cDevice::SetCamSlot(cCamSlot *CamSlot)
+ {
++  if (parentDevice)
++     return parentDevice->SetCamSlot(CamSlot);
+   camSlot = CamSlot;
+ }
+ 
+@@ -567,6 +608,10 @@ void cDevice::DelLivePids(void)
+ 
+ void cDevice::StartSectionHandler(void)
+ {
++  if (parentDevice) {
++     parentDevice->StartSectionHandler();
++     return;
++     }
+   if (!sectionHandler) {
+      sectionHandler = new cSectionHandler(this);
+      AttachFilter(eitFilter = new cEitFilter);
+@@ -578,6 +623,10 @@ void cDevice::StartSectionHandler(void)
+ 
+ void cDevice::StopSectionHandler(void)
+ {
++  if (parentDevice) {
++     parentDevice->StopSectionHandler();
++     return;
++     }
+   if (sectionHandler) {
+      delete nitFilter;
+      delete sdtFilter;
+@@ -609,12 +658,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);
+ }
+@@ -776,6 +830,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)
+@@ -822,19 +877,27 @@ void cDevice::ForceTransferMode(void)
+ {
+   if (!cTransferControl::ReceiverDevice()) {
+      cChannel *Channel = Channels.GetByNumber(CurrentChannel());
+-     if (Channel)
++     if (Channel) {
++        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);
+ }
+@@ -1209,7 +1272,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);
+@@ -1228,6 +1294,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()
+@@ -1247,6 +1315,8 @@ void cDevice::Detach(cPlayer *Player)
+ 
+ void cDevice::StopReplay(void)
+ {
++  if (parentDevice)
++     return parentDevice->StopReplay();
+   if (player) {
+      Detach(player);
+      if (IsPrimaryDevice())
+@@ -1529,6 +1599,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() && ActualDevice() == PrimaryDevice())
+      priority = TRANSFERPRIORITY; // we use the same value here, no matter whether it's actual Transfer Mode or real live viewing
+@@ -1547,6 +1619,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])
+@@ -1627,10 +1701,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
+@@ -1669,6 +1746,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;
+@@ -1694,6 +1773,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++) {
+@@ -1706,6 +1787,8 @@ void cDevice::DetachAll(int Pid)
+ 
+ void cDevice::DetachAllReceivers(void)
+ {
++  if (parentDevice)
++     return parentDevice->DetachAllReceivers();
+   cMutexLock MutexLock(&mutexReceiver);
+   for (int i = 0; i < MAXRECEIVERS; i++)
+       Detach(receiver[i]);
+@@ -1778,3 +1861,25 @@ uchar *cTSBuffer::Get(void)
+      }
+   return NULL;
+ }
++
++// --- cDynamicDeviceProbe -------------------------------------------------------
++
++cList<cDynamicDeviceProbe> DynamicDeviceProbes;
++
++cList<cDynamicDeviceProbe::cDynamicDeviceProbeItem> 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 1f94521..13abb17 100644
+--- a/device.h
++++ b/device.h
+@@ -169,7 +169,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
+@@ -196,9 +195,6 @@ protected:
+          ///< A derived class must call the MakePrimaryDevice() function of its
+          ///< base class.
+ public:
+-  bool IsPrimaryDevice(void) const { return this == primaryDevice; }
+-  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).
+   virtual cString DeviceType(void) const;
+@@ -423,9 +419,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
+ 
+@@ -581,9 +574,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);
+@@ -768,6 +758,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; }
++  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
+@@ -791,4 +813,47 @@ public:
+   uchar *Get(void);
+   };
+ 
++/// 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<cDynamicDeviceProbeItem> 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<cDynamicDeviceProbe> DynamicDeviceProbes;
++  
+ #endif //__DEVICE_H
+diff --git a/dvbci.c b/dvbci.c
+index 5289bbd..fea3a83 100644
+--- a/dvbci.c
++++ b/dvbci.c
+@@ -10,15 +10,18 @@
+ #include "dvbci.h"
+ #include <linux/dvb/ca.h>
+ #include <sys/ioctl.h>
+-#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("CI adapter on device %d", 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 adbe40d..6d117b2 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 9320da6..a0a69e5 100644
+--- a/dvbdevice.c
++++ b/dvbdevice.c
+@@ -287,7 +287,7 @@ private:
+   enum eTunerStatus { tsIdle, tsSet, tsTuned, tsLocked };
+   int frontendType;
+   const cDvbDevice *device;
+-  int fd_frontend;
++  mutable int fd_frontend;
+   int adapter, frontend;
+   uint32_t subsystemId;
+   int tuneTimeout;
+@@ -298,7 +298,7 @@ private:
+   const cScr *scr;
+   bool lnbPowerTurnedOn;
+   eTunerStatus tunerStatus;
+-  cMutex mutex;
++  mutable cMutex mutex;
+   cCondVar locked;
+   cCondVar newSet;
+   cDvbTuner *bondedTuner;
+@@ -311,6 +311,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();
+@@ -326,6 +330,9 @@ public:
+   bool Locked(int TimeoutMs = 0);
+   int GetSignalStrength(void) const;
+   int GetSignalQuality(void) const;
++
++  bool SetIdle(bool Idle);
++  bool IsIdle(void) const { return isIdle; }
+   };
+ 
+ cMutex cDvbTuner::bondMutex;
+@@ -347,6 +354,7 @@ cDvbTuner::cDvbTuner(const cDvbDevice *Device, int Fd_Frontend, int Adapter, int
+   tunerStatus = tsIdle;
+   bondedTuner = NULL;
+   bondedMaster = false;
++  isIdle = false;
+   SetDescription("tuner on frontend %d/%d", adapter, frontend);
+   Start();
+ }
+@@ -364,6 +372,8 @@ cDvbTuner::~cDvbTuner()
+      ExecuteDiseqc(lastDiseqc, &Frequency);
+      }
+   */
++  if (device && device->IsSubDevice())
++     CloseFrontend();
+ }
+ 
+ bool cDvbTuner::Bond(cDvbTuner *Tuner)
+@@ -508,6 +518,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;
+@@ -698,6 +710,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);\
+@@ -843,9 +857,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) {
+@@ -898,6 +914,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 {
+@@ -983,7 +1033,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;
+@@ -1003,7 +1054,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):
+ 
+@@ -1231,7 +1282,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<cDvbDevice *>(Device1)) {
+                      if (cDvbDevice *DvbDevice2 = dynamic_cast<cDvbDevice *>(Device2)) {
+                         if (!DvbDevice1->Bond(DvbDevice2))
+@@ -1265,7 +1320,10 @@ bool cDvbDevice::BondDevices(const char *Bondings)
+ void cDvbDevice::UnBondDevices(void)
+ {
+   for (int i = 0; i < cDevice::NumDevices(); i++) {
+-      if (cDvbDevice *d = dynamic_cast<cDvbDevice *>(cDevice::GetDevice(i)))
++      cDevice *dev = cDevice::GetDevice(i);
++      if (dev && dev->HasSubDevice())
++         dev = dev->SubDevice();
++      if (cDvbDevice *d = dynamic_cast<cDvbDevice *>(dev))
+          d->UnBond();
+       }
+ }
+@@ -1319,6 +1377,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;
+@@ -1485,7 +1563,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 7da9c56..e4f910b 100644
+--- a/dvbdevice.h
++++ b/dvbdevice.h
+@@ -107,7 +107,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:
+@@ -133,13 +133,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 bool Ready(void);
+   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),