Silence "misleading-indentation" warning.

Remove speed limit.
Avoid closing RTP/RTCP ports.
2023-10-10 11:37:42 +00:00 · 2018-03-14 23:23:27 +02:00 · 2018-02-13 17:24:09 +02:00 · 2018-02-06 22:55:52 +02:00 · 2018-02-06 22:36:59 +02:00 · 2017-11-19 15:25:31 +02:00
41 changed files with 1947 additions and 293 deletions
--- a/35
+++ b/35
@@ -130,3 +130,38 @@ VDR Plugin 'satip' Revision History
  (Thanks to Oliver Endriss).
 - Updated against SAT>IP protocol specification
  version 1.2.2.
+
+2015-04-26: Version 2.2.2
+
+- Added a more flexible OPER command in the SVDRP
+  interface.
+- Added new ATTA and DETA SVDRP commands.
+- Set the default device count to two.
+
+2015-09-18: Version 2.2.3
+
+- Added a timeout for releasing idling devices.
+- Reset the RTSP connection after any failed connect.
+- Added tweaks for minisatip and Schwaiger MS41IP.
+- Updated for vdr-2.3.1 (Thanks to Klaus Schmidinger).
+
+2016-12-18: Version 2.2.4
+
+- Updated German translation (Thanks to Frank Neumann).
+- Fixed Panasonic CXW804 support (Thanks to Tobias Grimm).
+- Fixed C++11 support (Thanks to Tobias Grimm).
+- Fixed server assigment with source validation (Thanks to Patrick Boettcher).
+- Added configurable RTP/RTCP ports (Thanks to chriszero).
+- Added support for X-SATIP-RTSP-Port header.
+- Added multicast and RTP-over-TCP support.
+- Added support for activating/deactivating server on-the-fly.
+- Extended command-line parameters for setting server quirks.
+
+2017-08-15: Version 2.2.5
+
+- Added Polish translation (Thanks to Tomasz Nowak).
+- Updated Catalan and Spanish translations (Thanks to Gabriel Bonich).
+- Added support for KATHREIN SatIP Server (Thanks to kavanu).
+- Added support for FRITZ!Box 6490 Cable (Thanks to 9000h).
+- Updated FRITZ!WLAN Repeater DVB-C detection for the latest firmware (Thanks to 9000h).
+- Added GCC7 compatibility (Thanks to Sascha Kuehndel).
--- a/35
+++ b/35
@@ -42,7 +42,7 @@ make -C satip-X.Y.Z install
 Configuration:

 The plugin accepts a "--devices" (-d) command-line parameter defaulting
-to one. This parameter defines how many simultaneous transponders can
+to two. This parameter defines how many simultaneous transponders can
 be received, if there are available SAT>IP tuners.

 The plugin accepts also a "--server" (-s) command-line parameter, that
@@ -52,9 +52,15 @@ separated list of "<ipaddress>|<model>|<description>" entries. The model
 consists of a DVB system (DVBS2,DVBT2,DVBT,DVBC) and number of available
 frontends separated by a hyphen:

-vdr -P 'satip -s <ipaddress>|<model>|<description>;...'
-vdr -P 'satip -s 192.168.0.1|DVBS2-2,DVBT2-2|Octo1'
-vdr -P 'satip -s 192.168.0.1|DVBS2-4|Octo1;192.168.0.2|DVBT2-4|Octo2'
+vdr -P 'satip -s [<srcaddress>@]<ipaddress>[:<port>]|<model>[:<filter>]|<description>[:<quirk>];...'
+vdr -P 'satip -s 192.168.0.1|DVBS2-2,DVBT2-2|OctopusNet'
+vdr -P 'satip -s 192.168.0.1|DVBS2-4|OctopusNet;192.168.0.2|DVBT2-4|minisatip:0x18'
+vdr -P 'satip -s 192.168.0.1:554|DVBS2-2:S19.2E|OctopusNet;192.168.0.2:8554|DVBS2-4:S19.2E,S1W|minisatip'
+
+The plugin accepts a "--portrange" (-p) command-line parameter, that can
+be used to manually specify the RTP & RTCP port range and therefore
+enables using the plugin through a NAT (e.g. Docker bridged network).
+A minimum of 2 ports per device is required.

 SAT>IP satellite positions (aka. signal sources) shall be defined via
 sources.conf. If the source description begins with a number, it's used
@@ -110,6 +116,11 @@ Setup menu:
                             "Disable filter" options which allow you
                             to disable the individual section filters.
                             Valid range: "none" = 0 ... 7
+- Transport mode = unicast   If you want to use the non-standard
+                   multicast RTP-over-TCP transport mode, set this option
+                   rtp-o-tcp accordingly. Otherwise, the transport
+                             mode will be RTP-over-UDP via unicast or
+                             multicast.
 - [Red:Scan]                 Forces network scanning of SAT>IP hardware.
 - [Yellow:Devices]           Opens SAT>IP device status menu.
 - [Blue:Info]                Opens SAT>IP information/statistics menu.
@@ -125,6 +136,9 @@ Information menu:

 Notes:

+- If you are having problems receiving DVB-S2 channels, make sure your
+  channels.conf entry contains correct pilot tone setting.
+
 - The stream id "-1" states about unsuccessful tuning. This might be a
  result of invalid channel parameters or lack of free SAT>IP tuners.

@@ -145,6 +159,19 @@ Notes:
  from their webpage: http://www.inverto.tv/support/
  An update to a newer firmware should be offered afterwards.

+- If you are experiencing glitches in the video stream, one possible
+  reason can be buffer overflows in RTP receive sockets. You can verify
+  this by checking "receive buffer errors" counter by running "netstat -s"
+  command. If the counter increases every time a video glitch happens,
+  you should try to tweak the RTP receive buffer size with the "--rcvbuf"
+  (-r) plugin parameter.
+  A good starting point for the buffer size is to double the operating
+  system default value until errors disappear or the maximum value is
+  reached. You can check these values in Linux by checking the kernel
+  parameters:
+  $ cat /proc/sys/net/core/rmem_default
+  $ cat /proc/sys/net/core/rmem_max
+
 Acknowledgements:

 - Big thanks to Digital Devices GmbH for providing the Octopus Net
--- a/common.h
+++ b/common.h
@@ -13,9 +13,11 @@
 #include <vdr/config.h>
 #include <vdr/i18n.h>

+#define SATIP_DEFAULT_RTSP_PORT          554
+
 #define SATIP_MAX_DEVICES                MAXDEVICES

-#define SATIP_BUFFER_SIZE                KILOBYTE(1024)
+#define SATIP_BUFFER_SIZE                KILOBYTE(2048)

 #define SATIP_DEVICE_INFO_ALL            0
 #define SATIP_DEVICE_INFO_GENERAL        1
@@ -48,15 +50,15 @@
     esyslog("curl_easy_perform() [%s,%d] failed: %s (%d)",  __FILE__, __LINE__, curl_easy_strerror(res), res); \
     }

-#define ERROR_IF_FUNC(exp, errstr, func, ret)                \
-  do {                                                       \
-     if (exp) {                                              \
-        char tmp[64];                                        \
-        esyslog("[%s,%d]: "errstr": %s", __FILE__, __LINE__, \
-                strerror_r(errno, tmp, sizeof(tmp)));        \
-        func;                                                \
-        ret;                                                 \
-        }                                                    \
+#define ERROR_IF_FUNC(exp, errstr, func, ret)                  \
+  do {                                                         \
+     if (exp) {                                                \
+        char tmp[64];                                          \
+        esyslog("[%s,%d]: " errstr ": %s", __FILE__, __LINE__, \
+                strerror_r(errno, tmp, sizeof(tmp)));          \
+        func;                                                  \
+        ret;                                                   \
+        }                                                      \
  } while (0)


--- a/config.c
+++ b/config.c
@@ -17,8 +17,13 @@ cSatipConfig::cSatipConfig(void)
  ciExtensionM(0),
  eitScanM(1),
  useBytesM(1),
+  portRangeStartM(0),
+  portRangeStopM(0),
+  transportModeM(eTransportModeUnicast),
+  detachedModeM(false),
  disableServerQuirksM(false),
-  useSingleModelServersM(false)
+  useSingleModelServersM(false),
+  rtpRcvBufSizeM(0)
 {
  for (unsigned int i = 0; i < ELEMENTS(cicamsM); ++i)
      cicamsM[i] = 0;
--- a/config.h
+++ b/config.h
@@ -19,11 +19,16 @@ private:
  unsigned int ciExtensionM;
  unsigned int eitScanM;
  unsigned int useBytesM;
+  unsigned int portRangeStartM;
+  unsigned int portRangeStopM;
+  unsigned int transportModeM;
+  bool detachedModeM;
  bool disableServerQuirksM;
  bool useSingleModelServersM;
  int cicamsM[MAX_CICAM_COUNT];
  int disabledSourcesM[MAX_DISABLED_SOURCES_COUNT];
  int disabledFiltersM[SECTION_FILTER_TABLE_SIZE];
+  size_t rtpRcvBufSizeM;

 public:
  enum eOperatingMode {
@@ -33,6 +38,12 @@ public:
    eOperatingModeHigh,
    eOperatingModeCount
  };
+  enum eTransportMode {
+    eTransportModeUnicast = 0,
+    eTransportModeMulticast,
+    eTransportModeRtpOverTcp,
+    eTransportModeCount
+  };
  enum eTraceMode {
    eTraceModeNormal  = 0x0000,
    eTraceModeDebug1  = 0x0001,
@@ -66,12 +77,20 @@ public:
  int GetCICAM(unsigned int indexP) const;
  unsigned int GetEITScan(void) const { return eitScanM; }
  unsigned int GetUseBytes(void) const { return useBytesM; }
+  unsigned int GetTransportMode(void) const { return transportModeM; }
+  bool IsTransportModeUnicast(void) const { return (transportModeM == eTransportModeUnicast); }
+  bool IsTransportModeRtpOverTcp(void) const { return (transportModeM == eTransportModeRtpOverTcp); }
+  bool IsTransportModeMulticast(void) const { return (transportModeM == eTransportModeMulticast); }
+  bool GetDetachedMode(void) const { return detachedModeM; }
  bool GetDisableServerQuirks(void) const { return disableServerQuirksM; }
  bool GetUseSingleModelServers(void) const { return useSingleModelServersM; }
  unsigned int GetDisabledSourcesCount(void) const;
  int GetDisabledSources(unsigned int indexP) const;
  unsigned int GetDisabledFiltersCount(void) const;
  int GetDisabledFilters(unsigned int indexP) const;
+  unsigned int GetPortRangeStart(void) const { return portRangeStartM; }
+  unsigned int GetPortRangeStop(void) const { return portRangeStopM; }
+  size_t GetRtpRcvBufSize(void) const { return rtpRcvBufSizeM; }

  void SetOperatingMode(unsigned int operatingModeP) { operatingModeM = operatingModeP; }
  void SetTraceMode(unsigned int modeP) { traceModeM = (modeP & eTraceModeMask); }
@@ -79,10 +98,15 @@ public:
  void SetCICAM(unsigned int indexP, int cicamP);
  void SetEITScan(unsigned int onOffP) { eitScanM = onOffP; }
  void SetUseBytes(unsigned int onOffP) { useBytesM = onOffP; }
+  void SetTransportMode(unsigned int transportModeP) { transportModeM = transportModeP; }
+  void SetDetachedMode(bool onOffP) { detachedModeM = onOffP; }
  void SetDisableServerQuirks(bool onOffP) { disableServerQuirksM = onOffP; }
  void SetUseSingleModelServers(bool onOffP) { useSingleModelServersM = onOffP; }
  void SetDisabledSources(unsigned int indexP, int sourceP);
  void SetDisabledFilters(unsigned int indexP, int numberP);
+  void SetPortRangeStart(unsigned int rangeStartP) { portRangeStartM = rangeStartP; }
+  void SetPortRangeStop(unsigned int rangeStopP) { portRangeStopM = rangeStopP; }
+  void SetRtpRcvBufSize(size_t sizeP) { rtpRcvBufSizeM = sizeP; }
 };

 extern cSatipConfig SatipConfig;
--- a/detectsatip.py
+++ b/detectsatip.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+""" Simple tool to detect SAT>IP devices as JSON.
+"""
+import json
+import socket
+import sys
+import xml.etree.ElementTree as ET
+import requests
+
+SSDP_BIND = '0.0.0.0'
+SSDP_ADDR = '239.255.255.250'
+SSDP_PORT = 1900
+SSDP_MX = 1
+SSDP_ST = 'urn:ses-com:device:SatIPServer:1'
+SSDP_REQUEST = 'M-SEARCH * HTTP/1.1\r\n' + \
+               'HOST: %s:%d\r\n' % (SSDP_ADDR, SSDP_PORT) + \
+               'MAN: "ssdp:discover"\r\n' + \
+               'MX: %d\r\n' % (SSDP_MX, ) + \
+               'ST: %s\r\n' % (SSDP_ST, ) + \
+               '\r\n'
+
+
+def parse_satip_xml(data):
+    """ Parse SAT>IP XML data.
+
+    Args:
+        data (str): XML input data..
+
+    Returns:
+        dict: Parsed SAT>IP device name and frontend information.
+    """
+    result = {'name': '', 'frontends': {}}
+    if data:
+        root = ET.fromstring(data)
+        name = root.find('.//*/{urn:schemas-upnp-org:device-1-0}friendlyName')
+        result['name'] = name.text
+        satipcap = root.find('.//*/{urn:ses-com:satip}X_SATIPCAP')
+        caps = {}
+        for system in satipcap.text.split(","):
+            cap = system.split("-")
+            if cap:
+                count = int(cap[1])
+                if cap[0] in caps:
+                    count = count + caps[cap[0]]
+                caps[cap[0]] = count
+        result['frontends'] = caps
+    return result
+
+
+def detect_satip_devices():
+    """ Detect available SAT>IP devices by sending a broadcast message.
+
+    Returns:
+        list: Found SAT>IP devices.
+    """
+    urls = []
+    devices = []
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setblocking(0)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    try:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+    except BaseException:
+        pass
+    sock.settimeout(1)
+    sock.bind((SSDP_BIND, SSDP_PORT))
+    sock.sendto(SSDP_REQUEST, (SSDP_ADDR, SSDP_PORT))
+    try:
+        while 1:
+            data = sock.recv(1024)
+            if data:
+                for row in data.split('\r\n'):
+                    if 'LOCATION:' in row:
+                        url = row.replace('LOCATION:', '').strip()
+                        if url in urls:
+                            continue
+                        urls.append(url)
+                        info = requests.get(url, timeout=2)
+                        devices.append(parse_satip_xml(info.text))
+            else:
+                break
+    except BaseException:
+        pass
+    sock.close()
+    return devices
+
+
+if __name__ == '__main__':
+    json.dump(detect_satip_devices(), fp=sys.stdout, sort_keys=True, indent=2)
--- a/device.c
+++ b/device.c
@@ -15,6 +15,8 @@

 static cSatipDevice * SatipDevicesS[SATIP_MAX_DEVICES] = { NULL };

+cMutex cSatipDevice::mutexS = cMutex();
+
 cSatipDevice::cSatipDevice(unsigned int indexP)
 : deviceIndexM(indexP),
  isPacketDeliveredM(false),
@@ -22,7 +24,7 @@ cSatipDevice::cSatipDevice(unsigned int indexP)
  deviceNameM(*cString::sprintf("%s %d", *DeviceType(), deviceIndexM)),
  channelM(),
  createdM(0),
-  mutexM()
+  tunedM()
 {
  unsigned int bufsize = (unsigned int)SATIP_BUFFER_SIZE;
  bufsize -= (bufsize % TS_SIZE);
@@ -42,6 +44,8 @@ cSatipDevice::cSatipDevice(unsigned int indexP)
 cSatipDevice::~cSatipDevice()
 {
  debug1("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
+  // Release immediately any pending conditional wait
+  tunedM.Broadcast();
  // Stop section handler
  StopSectionHandler();
  DELETE_POINTER(pSectionFilterHandlerM);
@@ -103,7 +107,12 @@ cString cSatipDevice::GetSatipStatus(void)
         bool live = (device == cDevice::ActualDevice());
         bool lock = device->HasLock();
         const cChannel *channel = device->GetCurrentlyTunedTransponder();
+#if defined(APIVERSNUM) && APIVERSNUM >= 20301
+         LOCK_TIMERS_READ;
+         for (const cTimer *timer = Timers->First(); timer; timer = Timers->Next(timer)) {
+#else
         for (cTimer *timer = Timers.First(); timer; timer = Timers.Next(timer)) {
+#endif
             if (timer->Recording()) {
                cRecordControl *control = cRecordControls::GetRecordControl(timer);
                if (control && control->Device() == device)
@@ -115,8 +124,12 @@ cString cSatipDevice::GetSatipStatus(void)
            info = cString::sprintf("%sCardIndex: %d  HasLock: yes  Strength: %d  Quality: %d%s\n", *info, device->CardIndex(), device->SignalStrength(), device->SignalQuality(), live ? "  Live: yes" : "");
         else
            info = cString::sprintf("%sCardIndex: %d  HasLock: no\n", *info, device->CardIndex());
-         if (channel && channel->Number() > 0)
-            info = cString::sprintf("%sTransponder: %d  Channel: %s\n", *info, (channel && channel->Number() > 0) ? channel->Transponder() : 0, (channel && channel->Number() > 0) ? channel->Name() : "---");
+         if (channel) {
+            if (channel->Number() > 0 && device->Receiving())
+               info = cString::sprintf("%sTransponder: %d  Channel: %s\n", *info, channel->Transponder(), channel->Name());
+            else
+               info = cString::sprintf("%sTransponder: %d\n", *info, channel->Transponder());
+            }
         if (timers)
            info = cString::sprintf("%sRecording: %d timer%s\n", *info, timers, (timers > 1) ? "s" : "");
         info = cString::sprintf("%s\n", *info);
@@ -128,13 +141,20 @@ cString cSatipDevice::GetSatipStatus(void)
 cString cSatipDevice::GetGeneralInformation(void)
 {
  debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
-  return cString::sprintf("SAT>IP device: %d\nCardIndex: %d\nStream: %s\nSignal: %s\nStream bitrate: %s\n%sChannel: %s",
+#if defined(APIVERSNUM) && APIVERSNUM >= 20301
+  LOCK_CHANNELS_READ;
+#endif
+  return cString::sprintf("SAT>IP device: %d\nCardIndex: %d\nStream: %s\nSignal: %s\nStream bitrate: %s\n%sChannel: %s\n",
                          deviceIndexM, CardIndex(),
                          pTunerM ? *pTunerM->GetInformation() : "",
                          pTunerM ? *pTunerM->GetSignalStatus() : "",
                          pTunerM ? *pTunerM->GetTunerStatistic() : "",
                          *GetBufferStatistic(),
+#if defined(APIVERSNUM) && APIVERSNUM >= 20301
+                          *Channels->GetByNumber(cDevice::CurrentChannel())->ToText());
+#else
                          *Channels.GetByNumber(cDevice::CurrentChannel())->ToText());
+#endif
 }

 cString cSatipDevice::GetPidsInformation(void)
@@ -194,6 +214,8 @@ cString cSatipDevice::DeviceType(void) const
 cString cSatipDevice::DeviceName(void) const
 {
  debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
+  if (!Receiving())
+     return cString::sprintf("%s %d", *DeviceType(), deviceIndexM);
  return deviceNameM;
 }

@@ -219,6 +241,8 @@ bool cSatipDevice::ProvidesSource(int sourceP) const
 {
  cSource *s = Sources.Get(sourceP);
  debug9("%s (%c) desc='%s' [device %u]", __PRETTY_FUNCTION__, cSource::ToChar(sourceP), s ? s->Description() : "", deviceIndexM);
+  if (SatipConfig.GetDetachedMode())
+     return false;
  // source descriptions starting with '0' are disabled
  if (s && s->Description() && (*(s->Description()) == '0'))
     return false;
@@ -319,6 +343,7 @@ bool cSatipDevice::MaySwitchTransponder(const cChannel *channelP) const

 bool cSatipDevice::SetChannelDevice(const cChannel *channelP, bool liveViewP)
 {
+  cMutexLock MutexLock(&mutexS);  // Global lock to prevent any simultaneous zapping
  debug9("%s (%d, %d) [device %u]", __PRETTY_FUNCTION__, channelP ? channelP->Number() : -1, liveViewP, deviceIndexM);
  if (channelP) {
     cDvbTransponderParameters dtp(channelP->Parameters());
@@ -336,23 +361,33 @@ bool cSatipDevice::SetChannelDevice(const cChannel *channelP, bool liveViewP)
     if (pTunerM && pTunerM->SetSource(server, channelP->Transponder(), *params, deviceIndexM)) {
        channelM = *channelP;
        deviceNameM = cString::sprintf("%s %d %s", *DeviceType(), deviceIndexM, *cSatipDiscover::GetInstance()->GetServerString(server));
+        // Wait for actual channel tuning to prevent simultaneous frontend allocation failures
+        tunedM.TimedWait(mutexS, eTuningTimeoutMs);
        return true;
        }
     }
  else if (pTunerM) {
     pTunerM->SetSource(NULL, 0, NULL, deviceIndexM);
+     deviceNameM = cString::sprintf("%s %d", *DeviceType(), deviceIndexM);
     return true;
     }
  return false;
 }

+void cSatipDevice::SetChannelTuned(void)
+{
+  debug9("%s () [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
+  // Release immediately any pending conditional wait
+  tunedM.Broadcast();
+}
+
 bool cSatipDevice::SetPid(cPidHandle *handleP, int typeP, bool onP)
 {
-  debug12("%s (%d, %d, %d) [device %u]", __PRETTY_FUNCTION__, handleP->pid, typeP, onP, deviceIndexM);
+  debug12("%s (%d, %d, %d) [device %u]", __PRETTY_FUNCTION__, handleP ? handleP->pid : -1, typeP, onP, deviceIndexM);
  if (pTunerM && handleP && handleP->pid >= 0) {
     if (onP)
        return pTunerM->SetPid(handleP->pid, typeP, true);
-     else if (!handleP->used)
+     else if (!handleP->used && pSectionFilterHandlerM && !pSectionFilterHandlerM->Exists(handleP->pid))
        return pTunerM->SetPid(handleP->pid, typeP, false);
     }
  return true;
@@ -458,6 +493,18 @@ int cSatipDevice::GetCISlot(void)
  return slot;
 }

+cString cSatipDevice::GetTnrParameterString(void)
+{
+   if (channelM.Ca())
+      return GetTnrUrlParameters(&channelM);
+   return NULL;
+}
+
+bool cSatipDevice::IsIdle(void)
+{
+  return !Receiving();
+}
+
 uchar *cSatipDevice::GetData(int *availableP)
 {
  debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
@@ -501,6 +548,8 @@ void cSatipDevice::SkipData(int countP)
 bool cSatipDevice::GetTSPacket(uchar *&dataP)
 {
  debug16("%s [device %u]", __PRETTY_FUNCTION__, deviceIndexM);
+  if (SatipConfig.GetDetachedMode())
+     return false;
  if (tsBufferM) {
     if (cCamSlot *cs = CamSlot()) {
        if (cs->WantsTsData()) {
--- a/device.h
+++ b/device.h
@@ -18,7 +18,7 @@
 class cSatipDevice : public cDevice, public cSatipPidStatistics, public cSatipBufferStatistics, public cSatipDeviceIf {
  // static ones
 public:
-  static unsigned int deviceCount;
+  static cMutex mutexS;
  static bool Initialize(unsigned int DeviceCount);
  static void Shutdown(void);
  static unsigned int Count(void);
@@ -28,7 +28,8 @@ public:
  // private parts
 private:
  enum {
-    eReadyTimeoutMs = 2000 // in milliseconds
+    eReadyTimeoutMs  = 2000, // in milliseconds
+    eTuningTimeoutMs = 1000  // in milliseconds
  };
  unsigned int deviceIndexM;
  bool isPacketDeliveredM;
@@ -39,11 +40,11 @@ private:
  cSatipTuner *pTunerM;
  cSatipSectionFilterHandler *pSectionFilterHandlerM;
  cTimeMs createdM;
-  cMutex mutexM;
+  cCondVar tunedM;

  // constructor & destructor
 public:
-  cSatipDevice(unsigned int deviceIndexP);
+  explicit cSatipDevice(unsigned int deviceIndexP);
  virtual ~cSatipDevice();
  cString GetInformation(unsigned int pageP = SATIP_DEVICE_INFO_ALL);

@@ -107,9 +108,12 @@ public:
  // for internal device interface
 public:
  virtual void WriteData(u_char *bufferP, int lengthP);
+  virtual void SetChannelTuned(void);
  virtual int GetId(void);
  virtual int GetPmtPid(void);
  virtual int GetCISlot(void);
+  virtual cString GetTnrParameterString(void);
+  virtual bool IsIdle(void);
 };

 #endif // __SATIP_DEVICE_H
--- a/deviceif.h
+++ b/deviceif.h
@@ -13,12 +13,15 @@ public:
  cSatipDeviceIf() {}
  virtual ~cSatipDeviceIf() {}
  virtual void WriteData(u_char *bufferP, int lengthP) = 0;
+  virtual void SetChannelTuned(void) = 0;
  virtual int GetId(void) = 0;
  virtual int GetPmtPid(void) = 0;
  virtual int GetCISlot(void) = 0;
+  virtual cString GetTnrParameterString(void) = 0;
+  virtual bool IsIdle(void) = 0;

 private:
-  cSatipDeviceIf(const cSatipDeviceIf&);
+  explicit cSatipDeviceIf(const cSatipDeviceIf&);
  cSatipDeviceIf& operator=(const cSatipDeviceIf&);
 };

--- a/discover.c
+++ b/discover.c
@@ -30,10 +30,10 @@ bool cSatipDiscover::Initialize(cSatipDiscoverServers *serversP)
 {
  debug1("%s", __PRETTY_FUNCTION__);
  if (instanceS) {
-       if (serversP) {
-          for (cSatipDiscoverServer *s = serversP->First(); s; s = serversP->Next(s))
-              instanceS->AddServer(s->IpAddress(), s->Model(), s->Description());
-          }
+     if (serversP) {
+        for (cSatipDiscoverServer *s = serversP->First(); s; s = serversP->Next(s))
+            instanceS->AddServer(s->SrcAddress(), s->IpAddress(), s->IpPort(), s->Model(), s->Filters(), s->Description(), s->Quirk());
+        }
     else
        instanceS->Activate();
     }
@@ -47,6 +47,18 @@ void cSatipDiscover::Destroy(void)
     instanceS->Deactivate();
 }

+size_t cSatipDiscover::HeaderCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP)
+{
+  cSatipDiscover *obj = reinterpret_cast<cSatipDiscover *>(dataP);
+  size_t len = sizeP * nmembP;
+  debug16("%s len=%zu", __PRETTY_FUNCTION__, len);
+
+  if (obj && (len > 0))
+     obj->headerBufferM.Add(ptrP, len);
+
+  return len;
+}
+
 size_t cSatipDiscover::DataCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP)
 {
  cSatipDiscover *obj = reinterpret_cast<cSatipDiscover *>(dataP);
@@ -91,6 +103,7 @@ int cSatipDiscover::DebugCallback(CURL *handleP, curl_infotype typeP, char *data
 cSatipDiscover::cSatipDiscover()
 : cThread("SATIP discover"),
  mutexM(),
+  headerBufferM(),
  dataBufferM(),
  msearchM(*this),
  probeUrlListM(),
@@ -176,7 +189,9 @@ void cSatipDiscover::Fetch(const char *urlP)
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_DEBUGFUNCTION, cSatipDiscover::DebugCallback);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_DEBUGDATA, this);

-     // Set callback
+     // Set header and data callbacks
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_HEADERFUNCTION, cSatipDiscover::HeaderCallback);
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEHEADER, this);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, cSatipDiscover::DataCallback);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, this);

@@ -199,7 +214,8 @@ void cSatipDiscover::Fetch(const char *urlP)
     SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_RESPONSE_CODE, &rc);
     SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_PRIMARY_IP, &addr);
     if (rc == 200) {
-        ParseDeviceInfo(addr);
+        ParseDeviceInfo(addr, ParseRtspPort());
+        headerBufferM.Reset();
        dataBufferM.Reset();
        }
     else
@@ -207,9 +223,32 @@ void cSatipDiscover::Fetch(const char *urlP)
     }
 }

-void cSatipDiscover::ParseDeviceInfo(const char *addrP)
+int cSatipDiscover::ParseRtspPort(void)
 {
-  debug1("%s (%s)", __PRETTY_FUNCTION__, addrP);
+  debug1("%s", __PRETTY_FUNCTION__);
+  char *s, *p = headerBufferM.Data();
+  char *r = strtok_r(p, "\r\n", &s);
+  int port = SATIP_DEFAULT_RTSP_PORT;
+
+  while (r) {
+        debug16("%s (%zu): %s", __PRETTY_FUNCTION__, headerBufferM.Size(), r);
+        r = skipspace(r);
+        if (strstr(r, "X-SATIP-RTSP-Port")) {
+           int tmp = -1;
+           if (sscanf(r, "X-SATIP-RTSP-Port:%11d", &tmp) == 1) {
+              port = tmp;
+              break;
+              }
+           }
+        r = strtok_r(NULL, "\r\n", &s);
+        }
+
+  return port;
+}
+
+void cSatipDiscover::ParseDeviceInfo(const char *addrP, const int portP)
+{
+  debug1("%s (%s, %d)", __PRETTY_FUNCTION__, addrP, portP);
  const char *desc = NULL, *model = NULL;
 #ifdef USE_TINYXML
  TiXmlDocument doc;
@@ -232,12 +271,12 @@ void cSatipDiscover::ParseDeviceInfo(const char *addrP)
        model = modelNode.text().as_string("DVBS2-1");
     }
 #endif
-  AddServer(addrP, model, desc);
+  AddServer(NULL, addrP, portP, model, NULL, desc, cSatipServer::eSatipQuirkNone);
 }

-void cSatipDiscover::AddServer(const char *addrP, const char *modelP, const char * descP)
+void cSatipDiscover::AddServer(const char *srcAddrP, const char *addrP, const int portP, const char *modelP, const char *filtersP, const char *descP, const int quirkP)
 {
-  debug1("%s (%s, %s, %s)", __PRETTY_FUNCTION__, addrP, modelP, descP);
+  debug1("%s (%s, %s, %d, %s, %s, %s, %d)", __PRETTY_FUNCTION__, srcAddrP, addrP, portP, modelP, filtersP, descP, quirkP);
  cMutexLock MutexLock(&mutexM);
  if (SatipConfig.GetUseSingleModelServers() && modelP && !isempty(modelP)) {
     int n = 0;
@@ -246,9 +285,9 @@ void cSatipDiscover::AddServer(const char *addrP, const char *modelP, const char
     while (r) {
           r = skipspace(r);
           cString desc = cString::sprintf("%s #%d", !isempty(descP) ? descP : "MyBrokenHardware", n++);
-           cSatipServer *tmp = new cSatipServer(addrP, r, desc);
+           cSatipServer *tmp = new cSatipServer(srcAddrP, addrP, portP, r, filtersP, desc, quirkP);
           if (!serversM.Update(tmp)) {
-              info("Adding server '%s|%s|%s' CI: %s Quirks: %s", tmp->Address(), tmp->Model(), tmp->Description(), tmp->HasCI() ? "yes" : "no", tmp->HasQuirk() ? tmp->Quirks() : "none");
+              info("Adding server '%s|%s|%s' Bind: %s Filters: %s CI: %s Quirks: %s", tmp->Address(), tmp->Model(), tmp->Description(), !isempty(tmp->SrcAddress()) ? tmp->SrcAddress() : "default", !isempty(tmp->Filters()) ? tmp->Filters() : "none", tmp->HasCI() ? "yes" : "no", tmp->HasQuirk() ? tmp->Quirks() : "none");
              serversM.Add(tmp);
              }
           else
@@ -258,9 +297,9 @@ void cSatipDiscover::AddServer(const char *addrP, const char *modelP, const char
     FREE_POINTER(p);
     }
  else {
-     cSatipServer *tmp = new cSatipServer(addrP, modelP, descP);
+     cSatipServer *tmp = new cSatipServer(srcAddrP, addrP, portP, modelP, filtersP, descP, quirkP);
     if (!serversM.Update(tmp)) {
-        info("Adding server '%s|%s|%s' CI: %s Quirks: %s", tmp->Address(), tmp->Model(), tmp->Description(), tmp->HasCI() ? "yes" : "no", tmp->HasQuirk() ? tmp->Quirks() : "none");
+        info("Adding server '%s|%s|%s' Bind: %s Filters: %s CI: %s Quirks: %s", tmp->Address(), tmp->Model(), tmp->Description(), !isempty(tmp->SrcAddress()) ? tmp->SrcAddress() : "default", !isempty(tmp->Filters()) ? tmp->Filters() : "none", tmp->HasCI() ? "yes" : "no", tmp->HasQuirk() ? tmp->Quirks() : "none");
        serversM.Add(tmp);
        }
     else
@@ -317,6 +356,13 @@ cString cSatipDiscover::GetServerList(void)
  return serversM.List();
 }

+void cSatipDiscover::ActivateServer(cSatipServer *serverP, bool onOffP)
+{
+  debug16("%s (, %d)", __PRETTY_FUNCTION__, onOffP);
+  cMutexLock MutexLock(&mutexM);
+  serversM.Activate(serverP, onOffP);
+}
+
 void cSatipDiscover::AttachServer(cSatipServer *serverP, int deviceIdP, int transponderP)
 {
  debug16("%s (, %d, %d)", __PRETTY_FUNCTION__, deviceIdP, transponderP);
@@ -345,6 +391,13 @@ bool cSatipDiscover::HasServerCI(cSatipServer *serverP)
  return serversM.HasCI(serverP);
 }

+cString cSatipDiscover::GetSourceAddress(cSatipServer *serverP)
+{
+  debug16("%s", __PRETTY_FUNCTION__);
+  cMutexLock MutexLock(&mutexM);
+  return serversM.GetSrcAddress(serverP);
+}
+
 cString cSatipDiscover::GetServerAddress(cSatipServer *serverP)
 {
  debug16("%s", __PRETTY_FUNCTION__);
@@ -352,6 +405,13 @@ cString cSatipDiscover::GetServerAddress(cSatipServer *serverP)
  return serversM.GetAddress(serverP);
 }

+int cSatipDiscover::GetServerPort(cSatipServer *serverP)
+{
+  debug16("%s", __PRETTY_FUNCTION__);
+  cMutexLock MutexLock(&mutexM);
+  return serversM.GetPort(serverP);
+}
+
 int cSatipDiscover::NumProvidedSystems(void)
 {
  debug16("%s", __PRETTY_FUNCTION__);
--- a/discover.h
+++ b/discover.h
@@ -21,16 +21,24 @@

 class cSatipDiscoverServer : public cListObject {
 private:
+  int ipPortM;
+  int quirkM;
+  cString srcAddressM;
  cString ipAddressM;
  cString descriptionM;
  cString modelM;
+  cString filtersM;
 public:
-  cSatipDiscoverServer(const char *ipAddressP, const char *modelP, const char *descriptionP)
+  cSatipDiscoverServer(const char *srcAddressP, const char *ipAddressP, const int ipPortP, const char *modelP, const char *filtersP, const char *descriptionP, const int quirkP)
  {
-    ipAddressM = ipAddressP; modelM = modelP; descriptionM = descriptionP;
+     srcAddressM = srcAddressP; ipAddressM = ipAddressP; ipPortM = ipPortP; modelM = modelP; filtersM = filtersP; descriptionM = descriptionP; quirkM = quirkP;
  }
+  int IpPort(void)              { return ipPortM; }
+  int Quirk(void)               { return quirkM; }
+  const char *SrcAddress(void)  { return *srcAddressM; }
  const char *IpAddress(void)   { return *ipAddressM; }
  const char *Model(void)       { return *modelM; }
+  const char *Filters(void)     { return *filtersM; }
  const char *Description(void) { return *descriptionM; }
 };

@@ -47,9 +55,11 @@ private:
    eCleanupTimeoutMs = 124000 // in milliseoonds
  };
  static cSatipDiscover *instanceS;
+  static size_t HeaderCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP);
  static size_t DataCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP);
  static int    DebugCallback(CURL *handleP, curl_infotype typeP, char *dataP, size_t sizeP, void *userPtrP);
  cMutex mutexM;
+  cSatipMemoryBuffer headerBufferM;
  cSatipMemoryBuffer dataBufferM;
  cSatipMsearch msearchM;
  cStringList probeUrlListM;
@@ -59,8 +69,9 @@ private:
  cSatipServers serversM;
  void Activate(void);
  void Deactivate(void);
-  void ParseDeviceInfo(const char *addrP);
-  void AddServer(const char *addrP, const char *modelP, const char *descP);
+  int ParseRtspPort(void);
+  void ParseDeviceInfo(const char *addrP, const int portP);
+  void AddServer(const char *srcAddrP, const char *addrP, const int portP, const char *modelP, const char *filtersP, const char *descP, const int quirkP);
  void Fetch(const char *urlP);
  // constructor
  cSatipDiscover();
@@ -83,11 +94,14 @@ public:
  cSatipServer *GetServer(cSatipServer *serverP);
  cSatipServers *GetServers(void);
  cString GetServerString(cSatipServer *serverP);
+  void ActivateServer(cSatipServer *serverP, bool onOffP);
  void AttachServer(cSatipServer *serverP, int deviceIdP, int transponderP);
  void DetachServer(cSatipServer *serverP, int deviceIdP, int transponderP);
  bool IsServerQuirk(cSatipServer *serverP, int quirkP);
  bool HasServerCI(cSatipServer *serverP);
  cString GetServerAddress(cSatipServer *serverP);
+  cString GetSourceAddress(cSatipServer *serverP);
+  int GetServerPort(cSatipServer *serverP);
  cString GetServerList(void);
  int NumProvidedSystems(void);

--- a/discoverif.h
+++ b/discoverif.h
@@ -15,7 +15,7 @@ public:
  virtual void SetUrl(const char *urlP) = 0;

 private:
-  cSatipDiscoverIf(const cSatipDiscoverIf&);
+  explicit cSatipDiscoverIf(const cSatipDiscoverIf&);
  cSatipDiscoverIf& operator=(const cSatipDiscoverIf&);
 };

--- a/msearch.c
+++ b/msearch.c
@@ -29,7 +29,7 @@ cSatipMsearch::cSatipMsearch(cSatipDiscoverIf &discoverP)
     memset(bufferM, 0, bufferLenM);
  else
     error("Cannot create Msearch buffer!");
-  if (!Open(eDiscoveryPort))
+  if (!Open(eDiscoveryPort, true))
     error("Cannot open Msearch port!");
 }

@@ -100,6 +100,11 @@ void cSatipMsearch::Process(void)
     }
 }

+void cSatipMsearch::Process(unsigned char *dataP, int lengthP)
+{
+  debug16("%s", __PRETTY_FUNCTION__);
+}
+
 cString cSatipMsearch::ToString(void) const
 {
  return "MSearch";
--- a/msearch.h
+++ b/msearch.h
@@ -26,7 +26,7 @@ private:
  bool registeredM;

 public:
-  cSatipMsearch(cSatipDiscoverIf &discoverP);
+  explicit cSatipMsearch(cSatipDiscoverIf &discoverP);
  virtual ~cSatipMsearch();
  void Probe(void);

@@ -34,6 +34,7 @@ public:
 public:
  virtual int GetFd(void);
  virtual void Process(void);
+  virtual void Process(unsigned char *dataP, int lengthP);
  virtual cString ToString(void) const;
 };

--- a/param.c
+++ b/param.c
@@ -163,34 +163,345 @@ cString GetTransponderUrlParameters(const cChannel *channelP)
       dtp.SetModulation(QPSK);
       dtp.SetRollOff(ROLLOFF_35);
       }
+     if ((channelP->Rid() % 100) > 0)
+                q += snprintf(q,       STBUFLEFT, "&fe=%d",           channelP->Rid() % 100);
+     ST(" S *") q += snprintf(q,       STBUFLEFT, "src=%d&",          ((src > 0) && (src <= 255)) ? src : 1);
+     if (freq >= 0L)
                q += snprintf(q,       STBUFLEFT, "freq=%s",          *dtoa(freq, "%lg"));
-     ST(" S *") q += snprintf(q,       STBUFLEFT, "&src=%d",          ((src > 0) && (src <= 255)) ? src : 1);
-     ST(" S *") q += snprintf(q,       STBUFLEFT, "&sr=%d",           channelP->Srate());
-     ST("C  1") q += snprintf(q,       STBUFLEFT, "&sr=%d",           channelP->Srate());
     ST(" S *") q += snprintf(q,       STBUFLEFT, "&pol=%c",          tolower(dtp.Polarization()));
-     ST("C T2") q += snprintf(q,       STBUFLEFT, "&plp=%d",          dtp.StreamId());
-     ST("  T2") q += snprintf(q,       STBUFLEFT, "&t2id=%d",         dtp.T2SystemId());
+     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.RollOff(),      SatipRollOffValues);
     ST("C  2") q += snprintf(q,       STBUFLEFT, "&c2tft=%d",        C2TuningFrequencyType);
-     ST("C  2") q += snprintf(q,       STBUFLEFT, "&ds=%d",           DataSlice);
-     ST("C  1") q += PrintUrlString(q, STBUFLEFT, dtp.Inversion(),    SatipInversionValues);
-     ST("  T2") q += PrintUrlString(q, STBUFLEFT, dtp.SisoMiso(),     SatipSisoMisoValues);
     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Bandwidth(),    SatipBandwidthValues);
     ST("C  2") q += PrintUrlString(q, STBUFLEFT, dtp.Bandwidth(),    SatipBandwidthValues);
-     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Guard(),        SatipGuardValues);
-     ST("CST*") q += PrintUrlString(q, STBUFLEFT, dtp.CoderateH(),    SatipCodeRateValues);
-     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.Pilot(),        SatipPilotValues);
-     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
-     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
-     ST("C  1") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
-     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.RollOff(),      SatipRollOffValues);
     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.System(),       SatipSystemValuesSat);
     ST("C  *") q += PrintUrlString(q, STBUFLEFT, dtp.System(),       SatipSystemValuesCable);
     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.System(),       SatipSystemValuesTerrestrial);
     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Transmission(), SatipTransmissionValues);
-     if ((channelP->Rid() % 100) > 0)
-                snprintf(q,            STBUFLEFT, "&fe=%d",           channelP->Rid() % 100);
+     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
+     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
+     ST("C  1") q += PrintUrlString(q, STBUFLEFT, dtp.Modulation(),   SatipModulationValues);
+     ST(" S *") q += PrintUrlString(q, STBUFLEFT, dtp.Pilot(),        SatipPilotValues);
+     ST(" S *") q += snprintf(q,       STBUFLEFT, "&sr=%d",           channelP->Srate());
+     ST("C  1") q += snprintf(q,       STBUFLEFT, "&sr=%d",           channelP->Srate());
+     ST("  T*") q += PrintUrlString(q, STBUFLEFT, dtp.Guard(),        SatipGuardValues);
+     ST("CST*") q += PrintUrlString(q, STBUFLEFT, dtp.CoderateH(),    SatipCodeRateValues);
+     ST("C  2") q += snprintf(q,       STBUFLEFT, "&ds=%d",           DataSlice);
+     ST("C T2") q += snprintf(q,       STBUFLEFT, "&plp=%d",          dtp.StreamId());
+     ST("  T2") q += snprintf(q,       STBUFLEFT, "&t2id=%d",         dtp.T2SystemId());
+     ST("  T2") q += PrintUrlString(q, STBUFLEFT, dtp.SisoMiso(),     SatipSisoMisoValues);
+     ST("C  1") q += PrintUrlString(q, STBUFLEFT, dtp.Inversion(),    SatipInversionValues);
 #undef ST
     return buffer;
     }
  return NULL;
 }
+
+cString GetTnrUrlParameters(const cChannel *channelP)
+{
+  if (channelP) {
+     cDvbTransponderParameters dtp(channelP->Parameters());
+     eTrackType track = cDevice::PrimaryDevice()->GetCurrentAudioTrack();
+
+     // TunerType: Byte;
+     //   0 = cable, 1 = satellite, 2 = terrestrial, 3 = atsc, 4 = iptv, 5 = stream (URL, DVBViewer GE)
+     int TunerType = 0;
+     if (channelP->IsCable())
+        TunerType = 0;
+     else if (channelP->IsSat())
+        TunerType = 1;
+     else if (channelP->IsTerr())
+        TunerType = 2;
+     else if (channelP->IsAtsc())
+        TunerType = 3;
+
+     // Frequency: DWord;
+     //   DVB-S: MHz if < 1000000, kHz if >= 1000000
+     //   DVB-T/C, ATSC: kHz
+     //   IPTV: IP address Byte3.Byte2.Byte1.Byte0
+     int Frequency = channelP->Frequency() / 1000;
+
+     // Symbolrate: DWord;
+     //   DVB S/C: in kSym/s
+     //   DVB-T, ATSC: 0
+     //   IPTV: Port
+     int Symbolrate = (channelP->IsSat() || channelP->IsCable()) ? channelP->Srate() : 0;
+
+     // LNB_LOF: Word;
+     //   DVB-S: Local oscillator frequency of the LNB
+     //   DVB-T/C, ATSC: 0
+     //   IPTV: Byte0 and Byte1 of Source IP
+     int LNB_LOF = channelP->IsSat() ? Setup.LnbSLOF : 0;
+
+     // Tone: Byte;
+     //   0 = off, 1 = 22 khz
+     int Tone = (channelP->Frequency() < Setup.LnbSLOF) ? 0 : 1;
+
+     // Polarity: Byte;
+     //   DVB-S polarity: 0 = horizontal, 1 = vertical, 2 = circular left, 3 = circular right
+     //   DVB-C modulation: 0 = Auto, 1 = 16QAM, 2 = 32QAM, 3 = 64QAM, 4 = 128QAM, 5 = 256 QAM
+     //   DVB-T bandwidth: 0 = 6 MHz, 1 = 7 MHz, 2 = 8 MHz
+     //   IPTV: Byte3 of SourceIP
+     int Polarity = 0;
+     if (channelP->IsSat()) {
+        switch (tolower(dtp.Polarization())) {
+          case 'h':
+               Polarity = 0;
+               break;
+          case 'v':
+               Polarity = 1;
+               break;
+          case 'l':
+               Polarity = 2;
+               break;
+          case 'r':
+               Polarity = 3;
+               break;
+          default:
+               break;
+          }
+        }
+     else if (channelP->IsCable()) {
+        switch (dtp.Modulation()) {
+          case 999:
+               Polarity = 0;
+               break;
+          case 16:
+               Polarity = 1;
+               break;
+          case 32:
+               Polarity = 2;
+               break;
+          case 64:
+               Polarity = 3;
+               break;
+          case 128:
+               Polarity = 4;
+               break;
+          case 256:
+               Polarity = 5;
+               break;
+          default:
+               break;
+          }
+        }
+     else if (channelP->IsTerr()) {
+        switch (dtp.Bandwidth()) {
+          case 6:
+               Polarity = 0;
+               break;
+          case 7:
+               Polarity = 1;
+               break;
+          case 8:
+               Polarity = 2;
+               break;
+          default:
+               break;
+          }
+        }
+
+     // DiSEqC: Byte;
+     //   0 = None
+     //   1 = Pos A (mostly translated to PosA/OptA)
+     //   2 = Pos B (mostly translated to PosB/OptA)
+     //   3 = PosA/OptA
+     //   4 = PosB/OptA
+     //   5 = PosA/OptB
+     //   6 = PosB/OptB
+     //   7 = Preset Position (DiSEqC 1.2, see DiSEqCExt)
+     //   8 = Angular Position (DiSEqC 1.2, see DiSEqCExt)
+     //   9 = DiSEqC Command Sequence (see DiSEqCExt)
+     int DiSEqC = 0;
+
+     // FEC: Byte;
+     //   0 = Auto
+     //   1 = 1/2
+     //   2 = 2/3
+     //   3 = 3/4
+     //   4 = 5/6
+     //   5 = 7/8
+     //   6 = 8/9
+     //   7 = 3/5
+     //   8 = 4/5
+     //   9 = 9/10
+     //   IPTV: Byte2 of SourceIP
+     //   DVB C/T, ATSC: 0
+     int FEC = 0;
+     if (channelP->IsSat()) {
+        switch (dtp.CoderateH()) {
+          case 999:
+               FEC = 0;
+               break;
+          case 12:
+               FEC = 1;
+               break;
+          case 23:
+               FEC = 2;
+               break;
+          case 34:
+               FEC = 3;
+               break;
+          case 56:
+               FEC = 4;
+               break;
+          case 78:
+               FEC = 5;
+               break;
+          case 89:
+               FEC = 6;
+               break;
+          case 35:
+               FEC = 7;
+               break;
+          case 45:
+               FEC = 8;
+               break;
+          case 910:
+               FEC = 9;
+               break;
+          default:
+               break;
+          }
+        }
+
+     // Audio_PID: Word;
+     int Audio_PID = channelP->Apid(0);
+     if (IS_AUDIO_TRACK(track))
+        Audio_PID = channelP->Apid(int(track - ttAudioFirst));
+     else if (IS_DOLBY_TRACK(track))
+        Audio_PID = channelP->Dpid(int(track - ttDolbyFirst));
+
+     // Video_PID: Word;
+     int Video_PID = channelP->Vpid();
+
+     // PMT_PID: Word;
+     int PMT_PID = channelP->Ppid();
+
+     // Service_ID: Word;
+     int Service_ID = channelP->Sid();
+
+     // SatModulation: Byte;
+     //   Bit 0..1: satellite modulation. 0 = Auto, 1 = QPSK, 2 = 8PSK, 3 = 16QAM or APSK for DVB-S2
+     //   Bit 2: modulation system. 0 = DVB-S/T/C, 1 = DVB-S2/T2/C2
+     //   Bit 3..4: DVB-S2: roll-off. 0 = 0.35, 1 = 0.25, 2 = 0.20, 3 = reserved
+     //   Bit 5..6: spectral inversion, 0 = undefined, 1 = auto, 2 = normal, 3 = inverted
+     //   Bit 7: DVB-S2: pilot symbols, 0 = off, 1 = on
+     //          DVB-T2: DVB-T2 Lite, 0 = off, 1 = on
+     int SatModulation = 0;
+     if (channelP->IsSat() && dtp.System()) {
+        switch (dtp.Modulation()) {
+          case 999:
+               SatModulation |= (0 & 0x3) << 0;
+               break;
+          case 2:
+               SatModulation |= (1 & 0x3) << 0;
+               break;
+          case 5:
+               SatModulation |= (2 & 0x3) << 0;
+               break;
+          case 6:
+               SatModulation |= (3 & 0x3) << 0;
+               break;
+          default:
+               break;
+          }
+        }
+     SatModulation |= (dtp.System() & 0x1) << 2;
+     if (channelP->IsSat() && dtp.System()) {
+        switch (dtp.RollOff()) {
+          case 35:
+               SatModulation |= (0 & 0x3) << 3;
+               break;
+          case 25:
+               SatModulation |= (1 & 0x3) << 3;
+               break;
+          case 20:
+               SatModulation |= (2 & 0x3) << 3;
+               break;
+          default:
+               break;
+          }
+        }
+     switch (dtp.Inversion()) {
+       case 999:
+           SatModulation |= (1 & 0x3) << 5;
+           break;
+       case 0:
+           SatModulation |= (2 & 0x3) << 5;
+           break;
+       case 1:
+           SatModulation |= (3 & 0x3) << 5;
+           break;
+       default:
+           break;
+       }
+     if (channelP->IsSat() && dtp.System()) {
+        switch (dtp.Pilot()) {
+          case 0:
+               SatModulation |= (0 & 0x1) << 7;
+               break;
+          case 1:
+               SatModulation |= (1 & 0x1) << 7;
+               break;
+          default:
+               break;
+          }
+        }
+
+     // DiSEqCExt: Word;
+     //   DiSEqC Extension, meaning depends on DiSEqC
+     //   DiSEqC = 0..6: 0
+     //   DiSEqC = 7: Preset Position (DiSEqC 1.2)
+     //   DiSEqC = 8: Orbital Position (DiSEqC 1.2, USALS, for calculating motor angle)
+     //               Same format as OrbitalPos above
+     //   DiSEQC = 9: Orbital Position referencing DiSEqC sequence defined in DiSEqC.xml/ini
+     //               Same format as OrbitalPos above
+     int DiSEqCExt = 0;
+
+     // Flags: Byte;
+     //   Bit 0: 1 = encrypted channel
+     //   Bit 1: reserved, set to 0
+     //   Bit 2: 1 = channel broadcasts RDS data
+     //   Bit 3: 1 = channel is a video service (even if the Video PID is temporarily = 0)
+     //   Bit 4: 1 = channel is an audio service (even if the Audio PID is temporarily = 0)
+     //   Bit 5: 1 = audio has a different samplerate than 48 KHz
+     //   Bit 6: 1 = bandstacking, internally polarisation is always set to H
+     //   Bit 7: 1 = channel entry is an additional audio track of the preceding
+     //              channel with bit 7 = 0
+     int Flags = (channelP->Ca() > 0xFF) ? 1 : 0;
+
+     // ChannelGroup: Byte;
+     //   0 = Group A, 1 = Group B, 2 = Group C etc.
+     int ChannelGroup = 0;
+
+     // TransportStream_ID: Word;
+     int TransportStream_ID = channelP->Tid();
+
+     // OriginalNetwork_ID: Word;
+     int OriginalNetwork_ID = channelP->Nid();
+
+     // Substream: Word;
+     //   DVB-S/C/T, ATSC, IPTV: 0
+     //   DVB-T2: 0 = PLP_ID not set, 1..256: PLP_ID + 1, 257... reserved
+     int Substream = (channelP->IsTerr() && dtp.System()) ? dtp.StreamId() - 1 : 0;
+
+     // OrbitalPos: Word;
+     //   DVB-S: orbital position x 10, 0 = undefined, 1..1800 east, 1801..3599 west (1°W = 3599)
+     //   DVB-C: 4000..4999
+     //   DVB-T: 5000..5999
+     //   ATSC:  6000..6999
+     //   IPTV:  7000..7999
+     //   Stream: 8000..8999
+     int OrbitalPos = 0;
+     if (channelP->IsSat()) {
+        OrbitalPos = cSource::Position(channelP->Source());
+        if (OrbitalPos != 3600)
+           OrbitalPos += 1800;
+        }
+
+     return cString::sprintf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
+                             TunerType, Frequency, Symbolrate, LNB_LOF, Tone, Polarity, DiSEqC, FEC, Audio_PID, Video_PID, PMT_PID, Service_ID,
+                             SatModulation, DiSEqCExt, Flags, ChannelGroup, TransportStream_ID, OriginalNetwork_ID, Substream, OrbitalPos);
+     }
+  return NULL;
+}
--- a/param.h
+++ b/param.h
@@ -11,5 +11,6 @@
 #include "common.h"

 cString GetTransponderUrlParameters(const cChannel *channelP);
+cString GetTnrUrlParameters(const cChannel *channelP);

 #endif // __SATIP_PARAM_H
--- a/po/ca_ES.po
+++ b/po/ca_ES.po
@@ -1,14 +1,14 @@
 # VDR plugin language source file.
-# Copyright (C) 2007-2015 Rolf Ahrenberg
+# Copyright (C) 2007-2017 Rolf Ahrenberg
 # This file is distributed under the same license as the satip package.
-# Gabriel Bonich, 2014-2015
+# Gabriel Bonich, 2014-2017
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: vdr-satip 2.2.1\n"
+"Project-Id-Version: vdr-satip 2.2.5\n"
 "Report-Msgid-Bugs-To: <see README>\n"
-"POT-Creation-Date: 2015-04-04 04:04+0300\n"
-"PO-Revision-Date: 2015-04-04 04:04+0300\n"
+"POT-Creation-Date: 2017-08-15 08:15+0300\n"
+"PO-Revision-Date: 2017-08-15 08:15+0300\n"
 "Last-Translator: Gabriel Bonich <gbonich@gmail.com>\n"
 "Language-Team: Catalan <vdr@linuxtv.org>\n"
 "Language: ca\n"
@@ -85,6 +85,15 @@ msgstr "Normal"
 msgid "high"
 msgstr "Alt"

+msgid "Unicast"
+msgstr "Unicast"
+
+msgid "Multicast"
+msgstr "Multicast"
+
+msgid "RTP-over-TCP"
+msgstr "RTP-per sobre-TCP"
+
 msgid "Button$Devices"
 msgstr "Dispositius"

@@ -178,6 +187,15 @@ msgstr "Filtra"
 msgid "Define an ill-behaving filter to be blacklisted."
 msgstr "Definir un filtre mal comportar a la llista negra."

+msgid "Transport mode"
+msgstr "Tipus de Transmissió"
+
+msgid ""
+"Define which transport mode shall be used.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+msgstr ""
+
 msgid "Active SAT>IP servers:"
 msgstr "Activa SAT>IP servers:"

--- a/po/de_DE.po
+++ b/po/de_DE.po
@@ -1,14 +1,14 @@
 # VDR plugin language source file.
-# Copyright (C) 2007-2015 Rolf Ahrenberg
+# Copyright (C) 2007-2017 Rolf Ahrenberg
 # This file is distributed under the same license as the satip package.
-# Frank Neumann, 2014-2015
+# Frank Neumann, 2014-2017
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: vdr-satip 2.2.1\n"
+"Project-Id-Version: vdr-satip 2.2.5\n"
 "Report-Msgid-Bugs-To: <see README>\n"
-"POT-Creation-Date: 2015-04-04 04:04+0300\n"
-"PO-Revision-Date: 2015-04-04 04:04+0300\n"
+"POT-Creation-Date: 2017-08-15 08:15+0300\n"
+"PO-Revision-Date: 2017-08-15 08:15+0300\n"
 "Last-Translator: Frank Neumann <fnu@yavdr.org>\n"
 "Language-Team: German <vdr@linuxtv.org>\n"
 "Language: de\n"
@@ -85,11 +85,20 @@ msgstr "normal"
 msgid "high"
 msgstr "hoch"

+msgid "Unicast"
+msgstr "Unicast"
+
+msgid "Multicast"
+msgstr "Multicast"
+
+msgid "RTP-over-TCP"
+msgstr "RTP-over-TCP"
+
 msgid "Button$Devices"
 msgstr "Geräte"

 msgid "Operating mode"
-msgstr "Betriebsmodus"
+msgstr "Betriebsart"

 msgid ""
 "Define the used operating mode for all SAT>IP devices:\n"
@@ -99,7 +108,7 @@ msgid ""
 "normal - devices are working within normal parameters\n"
 "high - devices are working at the highest priority"
 msgstr ""
-"Bestimme den Betriebsmodus für alle SAT>IP Geräte:\n"
+"Bestimme die Betriebsart für alle SAT>IP Geräte:\n"
 "\n"
 "aus - Geräte sind abgeschaltet\n"
 "niedrig - Geräte arbeiten mit geringster Priorität\n"
@@ -170,13 +179,25 @@ msgid ""
 msgstr ""
 "Bestimme die Anzahl der Abschnittsfilter die deaktiviert werden sollen.\n"
 "\n"
-"Bestimmte Abschnittsfilter können unerwünschtes Verhalten mit VDR, z.B. falsche Zeit-Synchronisation, verursachen. Durch das Ausblenden einzelner Filter können nützliche Daten dieser Abschnitte für den VDR erhalten werden."
+"Bestimmte Abschnittsfilter können unerwünschtes Verhalten mit VDR, z.B. falsche Zeit-Synchronisation, verursachen. Durch das Ausblenden einzelner Filter können nützliche Daten dieser Abschnitte für den VDR erhalten bleiben."

 msgid "Filter"
 msgstr "Filter"

 msgid "Define an ill-behaving filter to be blacklisted."
-msgstr "Bestimme einen fehlerhaften Filter der ausgeblendet werden soll."
+msgstr "Bestimme fehlerhafte Filter die ausgeblendet werden sollen."
+
+msgid "Transport mode"
+msgstr "Übertragungsart"
+
+msgid ""
+"Define which transport mode shall be used.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+msgstr ""
+"Lege die gewünschte Übertragungsart fest.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"

 msgid "Active SAT>IP servers:"
 msgstr "Aktive SAT>IP Server:"
--- a/po/es_ES.po
+++ b/po/es_ES.po
@@ -1,14 +1,14 @@
 # VDR plugin language source file.
-# Copyright (C) 2007-2015 Rolf Ahrenberg
+# Copyright (C) 2007-2017 Rolf Ahrenberg
 # This file is distributed under the same license as the satip package.
-# Gabriel Bonich, 2014-2015
+# Gabriel Bonich, 2014-2017
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: vdr-satip 2.2.1\n"
+"Project-Id-Version: vdr-satip 2.2.5\n"
 "Report-Msgid-Bugs-To: <see README>\n"
-"POT-Creation-Date: 2015-04-04 04:04+0300\n"
-"PO-Revision-Date: 2015-04-04 04:04+0300\n"
+"POT-Creation-Date: 2017-08-15 08:15+0300\n"
+"PO-Revision-Date: 2017-08-15 08:15+0300\n"
 "Last-Translator: Gabriel Bonich <gbonich@gmail.com>\n"
 "Language-Team: Spanish <vdr@linuxtv.org>\n"
 "Language: es\n"
@@ -85,6 +85,15 @@ msgstr "Normal"
 msgid "high"
 msgstr "Alto"

+msgid "Unicast"
+msgstr "Unicast"
+
+msgid "Multicast"
+msgstr "Multicast"
+
+msgid "RTP-over-TCP"
+msgstr "RTP-antes que-TCP"
+
 msgid "Button$Devices"
 msgstr "Dispositivos"

@@ -178,6 +187,15 @@ msgstr "Filtra"
 msgid "Define an ill-behaving filter to be blacklisted."
 msgstr "Define un filtro para poner en la lista negra."

+msgid "Transport mode"
+msgstr "Tipo de Transmisión"
+
+msgid ""
+"Define which transport mode shall be used.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+msgstr ""
+
 msgid "Active SAT>IP servers:"
 msgstr "Activa SAT>IP servers:"

--- a/po/fi_FI.po
+++ b/po/fi_FI.po
@@ -1,14 +1,14 @@
 # VDR plugin language source file.
-# Copyright (C) 2007-2015 Rolf Ahrenberg
+# Copyright (C) 2007-2017 Rolf Ahrenberg
 # This file is distributed under the same license as the satip package.
-# Rolf Ahrenberg, 2015
+# Rolf Ahrenberg, 2015-2017
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: vdr-satip 2.2.1\n"
+"Project-Id-Version: vdr-satip 2.2.5\n"
 "Report-Msgid-Bugs-To: <see README>\n"
-"POT-Creation-Date: 2015-04-04 04:04+0300\n"
-"PO-Revision-Date: 2015-04-04 04:04+0300\n"
+"POT-Creation-Date: 2017-08-15 08:15+0300\n"
+"PO-Revision-Date: 2017-08-15 08:15+0300\n"
 "Last-Translator: Rolf Ahrenberg\n"
 "Language-Team: Finnish <vdr@linuxtv.org>\n"
 "Language: fi\n"
@@ -85,6 +85,15 @@ msgstr "normaali"
 msgid "high"
 msgstr "korkea"

+msgid "Unicast"
+msgstr "Unicast"
+
+msgid "Multicast"
+msgstr "Multicast"
+
+msgid "RTP-over-TCP"
+msgstr "RTP-over-TCP"
+
 msgid "Button$Devices"
 msgstr "Laitteet"

@@ -177,6 +186,18 @@ msgstr "Suodatin"
 msgid "Define an ill-behaving filter to be blacklisted."
 msgstr "Määrittele käytöstä poistettava suodatin, joka lisätään mustalle listalle."

+msgid "Transport mode"
+msgstr "Siirtoyhteystapa"
+
+msgid ""
+"Define which transport mode shall be used.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+msgstr ""
+"Määrittele käytettävä siirtoyhteystapa.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+
 msgid "Active SAT>IP servers:"
 msgstr "Aktiiviset SAT>IP-palvelimet:"

--- a/po/pl_PL.po
+++ b/po/pl_PL.po
@@ -0,0 +1,206 @@
+# VDR plugin language source file.
+# Copyright (C) 2007-2017 Rolf Ahrenberg
+# This file is distributed under the same license as the vdr-satip package.
+# Tomasz Maciej Nowak, 2017
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: vdr-satip 2.2.5\n"
+"Report-Msgid-Bugs-To: <see README>\n"
+"POT-Creation-Date: 2017-08-15 08:15+0300\n"
+"PO-Revision-Date: 2017-08-15 08:15+0300\n"
+"Last-Translator: Tomasz Maciej Nowak <tomek_n@o2.pl>\n"
+"Language-Team: Polish <vdr@linuxtv.org>\n"
+"Language: pl_PL\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"X-Generator: Poedit 1.8.11\n"
+
+msgid "PAT (0x00)"
+msgstr "PAT (0x00)"
+
+msgid "NIT (0x40)"
+msgstr "NIT (0x40)"
+
+msgid "SDT (0x42)"
+msgstr "SDT (0x42)"
+
+msgid "EIT (0x4E/0x4F/0x5X/0x6X)"
+msgstr "EIT (0x4E/0x4F/0x5X/0x6X)"
+
+msgid "TDT (0x70)"
+msgstr "TDT (0x70)"
+
+msgid "SAT>IP information not available!"
+msgstr "Informacja o SAT>IP niedostępna!"
+
+msgid "SAT>IP Devices"
+msgstr "Urządzenia SAT>IP"
+
+msgid "SAT>IP Server"
+msgstr "Serwer SAT>IP"
+
+msgid "Address"
+msgstr "Adres"
+
+msgid "Model"
+msgstr "Model"
+
+msgid "Description"
+msgstr "Opis"
+
+msgid "CI extension"
+msgstr "Rozszerzenie CI"
+
+msgid "Creation date"
+msgstr "Data produkcji"
+
+msgid "SAT>IP Device Status"
+msgstr "Status urządzenia SAT>IP"
+
+msgid "SAT>IP Information"
+msgstr "SAT>IP - informacje"
+
+msgid "General"
+msgstr "Główne"
+
+msgid "Pids"
+msgstr "Pidy"
+
+msgid "Filters"
+msgstr "Filtry"
+
+msgid "Bits/bytes"
+msgstr "Bity/bajty"
+
+msgid "off"
+msgstr "wyłączone"
+
+msgid "low"
+msgstr "niski"
+
+msgid "normal"
+msgstr "normalny"
+
+msgid "high"
+msgstr "wysoki"
+
+msgid "Unicast"
+msgstr "Unicast"
+
+msgid "Multicast"
+msgstr "Multicast"
+
+msgid "RTP-over-TCP"
+msgstr "RTP-over-TCP"
+
+msgid "Button$Devices"
+msgstr "Urządzenia"
+
+msgid "Operating mode"
+msgstr "Tryb pracy"
+
+msgid ""
+"Define the used operating mode for all SAT>IP devices:\n"
+"\n"
+"off - devices are disabled\n"
+"low - devices are working at the lowest priority\n"
+"normal - devices are working within normal parameters\n"
+"high - devices are working at the highest priority"
+msgstr ""
+"Określa tryb pracy wszystkich urządzeń SAT>IP:\n"
+"\n"
+"wyłączone - urządzenia są wyłączone\n"
+"niski - urządzenia pracują z najniższym priorytetem\n"
+"normalny - urządzenia pracują z normalnymi parametrami\n"
+"wysoki - urządzenia pracują z najwyższym priorytetem"
+
+msgid "Enable CI extension"
+msgstr "Włącz rozszerzenie CI"
+
+msgid ""
+"Define whether a CI extension shall be used.\n"
+"\n"
+"This setting enables integrated CI/CAM handling found in some SAT>IP hardware (e.g. Digital Devices OctopusNet)."
+msgstr ""
+"Określa czy korzystać z rozszerzenia CI.\n"
+"\n"
+"To ustawienie włącza obsługę dostępnego czytnika CI/CAM w niektórych urządzeniach SAT>IP (np. Digital Devices OctopusNet)."
+
+msgid "CI/CAM"
+msgstr "CI/CAM"
+
+msgid ""
+"Define a desired CAM type for the CI slot.\n"
+"\n"
+"The '---' option lets SAT>IP hardware do the auto-selection."
+msgstr ""
+"Określa typ modułu CAM w czytniku CI.\n"
+"\n"
+"Opcja '---' pozwala urządzeniu SAT>IP automatycznie wybrać typ."
+
+msgid "Enable EPG scanning"
+msgstr "Włącz skanowanie EPG"
+
+msgid ""
+"Define whether the EPG background scanning shall be used.\n"
+"\n"
+"This setting disables the automatic EIT scanning functionality for all SAT>IP devices."
+msgstr ""
+"Określa czy przeprowadzać skanowanie EPG w tle.\n"
+"\n"
+"To ustawienie wyłącza funkcję automatycznego skanowania EIT dla wszystkich urządzeń SAT>IP."
+
+msgid "Disabled sources"
+msgstr "Wyłączone źródła"
+
+msgid "none"
+msgstr "brak"
+
+msgid ""
+"Define number of sources to be disabled.\n"
+"\n"
+"SAT>IP servers might not have all satellite positions available and such sources can be blacklisted here."
+msgstr ""
+"Określa liczbę wyłączonych źródeł.\n"
+"\n"
+"Serwery SAT>IP mogą nie mieć dostępu do niektórych pozycji satelitarnych, więc tutaj można je wyłączyć."
+
+msgid "Define a source to be blacklisted."
+msgstr "Określ źródła do wyłączenia."
+
+msgid "Disabled filters"
+msgstr "Wyłączone filtry"
+
+msgid ""
+"Define number of section filters to be disabled.\n"
+"\n"
+"Certain section filters might cause some unwanted behaviour to VDR such as time being falsely synchronized. By blacklisting the filters here, useful section data can be left intact for VDR to process."
+msgstr ""
+"Określa liczbę wyłączonych filtrów sekcji.\n"
+"\n"
+"Niektóre filtry sekcji mogą powodować niezamierzone efekty w VDR, takie jak zły czas synchronizacji. Poprzez wyłączenie niektórych filtrów, użyteczne dane sekcji będą dostępne do przetworzenia dla VDR."
+
+msgid "Filter"
+msgstr "Filtr"
+
+msgid "Define an ill-behaving filter to be blacklisted."
+msgstr "Określa filtry powodujące zakłócenia, które mają być wyłączone."
+
+msgid "Transport mode"
+msgstr "Tryb"
+
+msgid ""
+"Define which transport mode shall be used.\n"
+"\n"
+"Unicast, Multicast, RTP-over-TCP"
+msgstr ""
+"Określa tryb transmisji.\n"
+"Unicast, Multicast, RTP-over-TCP."
+
+msgid "Active SAT>IP servers:"
+msgstr "Aktywne serwery SAT>IP:"
+
+msgid "Help"
+msgstr "Pomoc"
--- a/poller.c
+++ b/poller.c
@@ -79,7 +79,7 @@ void cSatipPoller::Action(void)
  // Do the thread loop
  while (Running()) {
        int nfds = epoll_wait(fdM, events, eMaxFileDescriptors, -1);
-        ERROR_IF_FUNC((nfds == -1), "epoll_wait() failed", break, ;);
+        ERROR_IF_FUNC((nfds == -1 && errno != EINTR), "epoll_wait() failed", break, ;);
        for (int i = 0; i < nfds; ++i) {
            cSatipPollerIf* poll = reinterpret_cast<cSatipPollerIf *>(events[i].data.ptr);
            if (poll) {
--- a/pollerif.h
+++ b/pollerif.h
@@ -14,10 +14,11 @@ public:
  virtual ~cSatipPollerIf() {}
  virtual int GetFd(void) = 0;
  virtual void Process(void) = 0;
+  virtual void Process(unsigned char *dataP, int lengthP) = 0;
  virtual cString ToString(void) const = 0;

 private:
-  cSatipPollerIf(const cSatipPollerIf&);
+  explicit cSatipPollerIf(const cSatipPollerIf&);
  cSatipPollerIf& operator=(const cSatipPollerIf&);
 };

--- a/rtcp.c
+++ b/rtcp.c
@@ -36,7 +36,7 @@ int cSatipRtcp::GetFd(void)

 int cSatipRtcp::GetApplicationOffset(int *lengthP)
 {
-  debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, *lengthP, tunerM.GetId());
+  debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, lengthP ? *lengthP : -1, tunerM.GetId());
  if (!lengthP)
     return -1;
  int offset = 0;
@@ -92,6 +92,16 @@ void cSatipRtcp::Process(void)
     }
 }

+void cSatipRtcp::Process(unsigned char *dataP, int lengthP)
+{
+  debug16("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
+  if (dataP && lengthP > 0) {
+     int offset = GetApplicationOffset(&lengthP);
+     if (offset >= 0)
+        tunerM.ProcessApplicationData(dataP + offset, lengthP);
+     }
+}
+
 cString cSatipRtcp::ToString(void) const
 {
  return cString::sprintf("RTCP [device %d]", tunerM.GetId());
--- a/rtcp.h
+++ b/rtcp.h
@@ -23,13 +23,14 @@ private:
  int GetApplicationOffset(int *lengthP);

 public:
-  cSatipRtcp(cSatipTunerIf &tunerP);
+  explicit cSatipRtcp(cSatipTunerIf &tunerP);
  virtual ~cSatipRtcp();

  // for internal poller interface
 public:
  virtual int GetFd(void);
  virtual void Process(void);
+  virtual void Process(unsigned char *dataP, int lengthP);
  virtual cString ToString(void) const;
 };

--- a/rtp.c
+++ b/rtp.c
@@ -14,7 +14,8 @@
 #include "rtp.h"

 cSatipRtp::cSatipRtp(cSatipTunerIf &tunerP)
-: tunerM(tunerP),
+: cSatipSocket(SatipConfig.GetRtpRcvBufSize()),
+  tunerM(tunerP),
  bufferLenM(eRtpPacketReadCount * eMaxUdpPacketSizeB),
  bufferM(MALLOC(unsigned char, bufferLenM)),
  lastErrorReportM(0),
@@ -45,7 +46,7 @@ void cSatipRtp::Close(void)

  sequenceNumberM = -1;
  if (packetErrorsM) {
-     info("Detected %d RTP packet errors [device %d]", packetErrorsM, tunerM.GetId());
+     info("Detected %d RTP packet error%s [device %d]", packetErrorsM, packetErrorsM == 1 ? "": "s", tunerM.GetId());
     packetErrorsM = 0;
     lastErrorReportM = time(NULL);
     }
@@ -80,7 +81,7 @@ int cSatipRtp::GetHeaderLength(unsigned char *bufferP, unsigned int lengthP)
        else if ((sequenceNumberM >= 0) && (((sequenceNumberM + 1) % 0xFFFF) != seq)) {
           packetErrorsM++;
           if (time(NULL) - lastErrorReportM > eReportIntervalS) {
-              info("Detected %d RTP packet errors [device %d]", packetErrorsM, tunerM.GetId());
+              info("Detected %d RTP packet error%s [device %d]", packetErrorsM, packetErrorsM == 1 ? "": "s", tunerM.GetId());
              packetErrorsM = 0;
              lastErrorReportM = time(NULL);
              }
@@ -142,6 +143,22 @@ void cSatipRtp::Process(void)
     }
 }

+void cSatipRtp::Process(unsigned char *dataP, int lengthP)
+{
+  debug16("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
+  if (dataP && lengthP > 0) {
+     uint64_t elapsed;
+     cTimeMs processing(0);
+     int headerlen = GetHeaderLength(dataP, lengthP);
+     if ((headerlen >= 0) && (headerlen < lengthP))
+        tunerM.ProcessVideoData(dataP + headerlen, lengthP - headerlen);
+
+     elapsed = processing.Elapsed();
+     if (elapsed > 1)
+        debug6("%s %d read(s) took %" PRIu64 " ms [device %d]", __PRETTY_FUNCTION__, lengthP, elapsed, tunerM.GetId());
+     }
+}
+
 cString cSatipRtp::ToString(void) const
 {
  return cString::sprintf("RTP [device %d]", tunerM.GetId());
--- a/rtp.h
+++ b/rtp.h
@@ -28,7 +28,7 @@ private:
  int GetHeaderLength(unsigned char *bufferP, unsigned int lengthP);

 public:
-  cSatipRtp(cSatipTunerIf &tunerP);
+  explicit cSatipRtp(cSatipTunerIf &tunerP);
  virtual ~cSatipRtp();
  virtual void Close(void);

@@ -36,6 +36,7 @@ public:
 public:
  virtual int GetFd(void);
  virtual void Process(void);
+  virtual void Process(unsigned char *dataP, int lengthP);
  virtual cString ToString(void) const;
 };

--- a/rtsp.c
+++ b/rtsp.c
@@ -17,12 +17,14 @@ cSatipRtsp::cSatipRtsp(cSatipTunerIf &tunerP)
 : tunerM(tunerP),
  headerBufferM(),
  dataBufferM(),
-  modeM(cmUnicast),
  handleM(NULL),
  headerListM(NULL),
  errorNoMoreM(""),
  errorOutOfRangeM(""),
-  errorCheckSyntaxM("")
+  errorCheckSyntaxM(""),
+  modeM(cSatipConfig::eTransportModeUnicast),
+  interleavedRtpIdM(0),
+  interleavedRtcpIdM(1)
 {
  debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
  Create();
@@ -58,6 +60,30 @@ size_t cSatipRtsp::DataCallback(char *ptrP, size_t sizeP, size_t nmembP, void *d
  return len;
 }

+size_t cSatipRtsp::InterleaveCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP)
+{
+  cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(dataP);
+  size_t len = sizeP * nmembP;
+  debug16("%s len=%zu", __PRETTY_FUNCTION__, len);
+
+  if (obj && ptrP && len > 0) {
+     char tag = ptrP[0] & 0xFF;
+     if (tag == '$') {
+        int count = ((ptrP[2] & 0xFF) << 8) | (ptrP[3] & 0xFF);
+        if (count > 0) {
+           unsigned int channel = ptrP[1] & 0xFF;
+           u_char *data = (u_char *)&ptrP[4];
+           if (channel == obj->interleavedRtpIdM)
+              obj->tunerM.ProcessRtpData(data, count);
+           else if (channel == obj->interleavedRtcpIdM)
+              obj->tunerM.ProcessRtcpData(data, count);
+           }
+        }
+     }
+
+  return len;
+}
+
 int cSatipRtsp::DebugCallback(CURL *handleP, curl_infotype typeP, char *dataP, size_t sizeP, void *userPtrP)
 {
  cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(userPtrP);
@@ -87,6 +113,21 @@ int cSatipRtsp::DebugCallback(CURL *handleP, curl_infotype typeP, char *dataP, s
  return 0;
 }

+cString cSatipRtsp::GetActiveMode(void)
+{
+  switch (modeM) {
+    case cSatipConfig::eTransportModeUnicast:
+         return "Unicast";
+    case cSatipConfig::eTransportModeMulticast:
+         return "Multicast";
+    case cSatipConfig::eTransportModeRtpOverTcp:
+         return "RTP-over-TCP";
+    default:
+         break;
+    }
+  return "";
+}
+
 cString cSatipRtsp::RtspUnescapeString(const char *strP)
 {
  debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, strP, tunerM.GetId());
@@ -149,6 +190,22 @@ void cSatipRtsp::Reset(void)
  Create();
 }

+bool cSatipRtsp::SetInterface(const char *bindAddrP)
+{
+  debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, bindAddrP, tunerM.GetId());
+  bool result = true;
+  CURLcode res = CURLE_OK;
+
+  if (handleM && !isempty(bindAddrP)) {
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERFACE, *cString::sprintf("host!%s", bindAddrP));
+     }
+  else {
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERFACE, NULL);
+     }
+
+  return result;
+}
+
 bool cSatipRtsp::Options(const char *uriP)
 {
  debug1("%s (%s) [device %d]", __PRETTY_FUNCTION__, uriP, tunerM.GetId());
@@ -171,9 +228,9 @@ bool cSatipRtsp::Options(const char *uriP)
  return result;
 }

-bool cSatipRtsp::Setup(const char *uriP, int rtpPortP, int rtcpPortP)
+bool cSatipRtsp::Setup(const char *uriP, int rtpPortP, int rtcpPortP, bool useTcpP)
 {
-  debug1("%s (%s, %d, %d) [device %d]", __PRETTY_FUNCTION__, uriP, rtpPortP, rtcpPortP, tunerM.GetId());
+  debug1("%s (%s, %d, %d, %d) [device %d]", __PRETTY_FUNCTION__, uriP, rtpPortP, rtcpPortP, useTcpP, tunerM.GetId());
  bool result = false;

  if (handleM && !isempty(uriP)) {
@@ -182,15 +239,18 @@ bool cSatipRtsp::Setup(const char *uriP, int rtpPortP, int rtcpPortP)
     cTimeMs processing(0);
     CURLcode res = CURLE_OK;

-     switch (modeM) {
-       case cmMulticast:
-            // RTP/AVP;multicast;destination=<IP multicast address>;port=<RTP port>-<RTCP port>;ttl=<ttl>
-            transport = cString::sprintf("RTP/AVP;multicast;port=%d-%d", rtpPortP, rtcpPortP);
+     switch (SatipConfig.GetTransportMode()) {
+       case cSatipConfig::eTransportModeMulticast:
+            // RTP/AVP;multicast;destination=<multicast group address>;port=<RTP port>-<RTCP port>;ttl=<ttl>[;source=<multicast source address>]
+            transport = cString::sprintf("RTP/AVP;multicast");
            break;
       default:
-       case cmUnicast:
            // RTP/AVP;unicast;client_port=<client RTP port>-<client RTCP port>
-            transport = cString::sprintf("RTP/AVP;unicast;client_port=%d-%d", rtpPortP, rtcpPortP);
+            // RTP/AVP/TCP;unicast;client_port=<client RTP port>-<client RTCP port>
+            if (useTcpP)
+               transport = cString::sprintf("RTP/AVP/TCP;unicast;interleaved=%u-%u", interleavedRtpIdM, interleavedRtcpIdM);
+            else
+               transport = cString::sprintf("RTP/AVP;unicast;client_port=%d-%d", rtpPortP, rtcpPortP);
            break;
       }

@@ -203,6 +263,9 @@ bool cSatipRtsp::Setup(const char *uriP, int rtpPortP, int rtcpPortP)
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEHEADER, this);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, cSatipRtsp::DataCallback);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, this);
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEFUNCTION, NULL);
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEDATA, NULL);
+
     SATIP_CURL_EASY_PERFORM(handleM);
     // Session id is now known - disable header parsing
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_HEADERFUNCTION, NULL);
@@ -310,6 +373,8 @@ bool cSatipRtsp::Teardown(const char *uriP)
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_RTSP_REQUEST, (long)CURL_RTSPREQ_TEARDOWN);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, cSatipRtsp::DataCallback);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, this);
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEFUNCTION, NULL);
+     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEDATA, NULL);
     SATIP_CURL_EASY_PERFORM(handleM);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEFUNCTION, NULL);
     SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_WRITEDATA, NULL);
@@ -351,6 +416,35 @@ void cSatipRtsp::ParseHeader(void)
              tunerM.SetSessionTimeout(skipspace(session), -1);
           FREE_POINTER(session);
           }
+        else if (strstr(r, "Transport:")) {
+           CURLcode res = CURLE_OK;
+           int rtp = -1, rtcp = -1, ttl = -1;
+           char *tmp = NULL, *destination = NULL, *source = NULL;
+           interleavedRtpIdM = 0;
+           interleavedRtcpIdM = 1;
+           SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEFUNCTION, NULL);
+           SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEDATA, NULL);
+           if (sscanf(r, "Transport:%m[^;];unicast;client_port=%11d-%11d", &tmp, &rtp, &rtcp) == 3) {
+              modeM = cSatipConfig::eTransportModeUnicast;
+              tunerM.SetupTransport(rtp, rtcp, NULL, NULL);
+              }
+           else if (sscanf(r, "Transport:%m[^;];multicast;destination=%m[^;];port=%11d-%11d;ttl=%11d;source=%m[^;]", &tmp, &destination, &rtp, &rtcp, &ttl, &source) == 6 ||
+                    sscanf(r, "Transport:%m[^;];multicast;destination=%m[^;];port=%11d-%11d;ttl=%11d", &tmp, &destination, &rtp, &rtcp, &ttl) == 5) {
+              modeM = cSatipConfig::eTransportModeMulticast;
+              tunerM.SetupTransport(rtp, rtcp, destination, source);
+              }
+           else if (sscanf(r, "Transport:%m[^;];interleaved=%11d-%11d", &tmp, &rtp, &rtcp) == 3) {
+              interleavedRtpIdM = rtp;
+              interleavedRtcpIdM = rtcp;
+              SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEFUNCTION, cSatipRtsp::InterleaveCallback);
+              SATIP_CURL_EASY_SETOPT(handleM, CURLOPT_INTERLEAVEDATA, this);
+              modeM = cSatipConfig::eTransportModeRtpOverTcp;
+              tunerM.SetupTransport(-1, -1, NULL, NULL);
+              }
+           FREE_POINTER(tmp);
+           FREE_POINTER(destination);
+           FREE_POINTER(source);
+           }
        r = strtok_r(NULL, "\r\n", &s);
        }
 }
@@ -418,10 +512,12 @@ bool cSatipRtsp::ValidateLatestResponse(long *rcP)
            // SETUP PLAY TEARDOWN
            // The message body of the response may contain the "Out-of-Range:" parameter followed
            // by a space-separated list of the attribute names that are not understood:
-            // "src" "fe" "freq" "pol" "msys" "mtype" "plts" "ro" "sr" "fec" "pids" "addpids" "delpids" "mcast
+            // "src" "fe" "freq" "pol" "msys" "mtype" "plts" "ro" "sr" "fec" "pids" "addpids" "delpids" "mcast"
            if (!isempty(*errorOutOfRangeM)) {
               SATIP_CURL_EASY_GETINFO(handleM, CURLINFO_EFFECTIVE_URL, &url);
               error("Out of range: %s (error code %ld: %s) [device %d]", *errorOutOfRangeM, rc, url, tunerM.GetId());
+               // Reseting the connection wouldn't help anything due to invalid channel configuration, so let it be successful
+               result = true;
               break;
               }
       case 503:
--- a/rtsp.h
+++ b/rtsp.h
@@ -22,22 +22,24 @@ class cSatipRtsp {
 private:
  static size_t HeaderCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP);
  static size_t DataCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP);
+  static size_t InterleaveCallback(char *ptrP, size_t sizeP, size_t nmembP, void *dataP);
  static int    DebugCallback(CURL *handleP, curl_infotype typeP, char *dataP, size_t sizeP, void *userPtrP);

  enum {
-    eConnectTimeoutMs = 1500,  // in milliseconds
+    eConnectTimeoutMs      = 1500,  // in milliseconds
  };
-  enum eCommunicationMode { cmUnicast, cmMulticast };

  cSatipTunerIf &tunerM;
  cSatipMemoryBuffer headerBufferM;
  cSatipMemoryBuffer dataBufferM;
-  eCommunicationMode modeM;
  CURL *handleM;
  struct curl_slist *headerListM;
  cString errorNoMoreM;
  cString errorOutOfRangeM;
  cString errorCheckSyntaxM;
+  int modeM;
+  unsigned int interleavedRtpIdM;
+  unsigned int interleavedRtcpIdM;

  void Create(void);
  void Destroy(void);
@@ -50,13 +52,15 @@ private:
  cSatipRtsp& operator=(const cSatipRtsp&);

 public:
-  cSatipRtsp(cSatipTunerIf &tunerP);
+  explicit cSatipRtsp(cSatipTunerIf &tunerP);
  virtual ~cSatipRtsp();

+  cString GetActiveMode(void);
  cString RtspUnescapeString(const char *strP);
  void Reset(void);
+  bool SetInterface(const char *bindAddrP);
  bool Options(const char *uriP);
-  bool Setup(const char *uriP, int rtpPortP, int rtcpPortP);
+  bool Setup(const char *uriP, int rtpPortP, int rtcpPortP, bool useTcpP);
  bool SetSession(const char *sessionP);
  bool Describe(const char *uriP);
  bool Play(const char *uriP);
--- a/satip.c
+++ b/satip.c
@@ -5,6 +5,7 @@
 *
 */

+#include <ctype.h>
 #include <getopt.h>
 #include <vdr/plugin.h>
 #include "common.h"
@@ -27,7 +28,7 @@
 #define GITVERSION ""
 #endif

-       const char VERSION[]     = "2.2.1" GITVERSION;
+       const char VERSION[]     = "2.2.5" GITVERSION;
 static const char DESCRIPTION[] = trNOOP("SAT>IP Devices");

 class cPluginSatip : public cPlugin {
@@ -35,6 +36,7 @@ private:
  unsigned int deviceCountM;
  cSatipDiscoverServers *serversM;
  void ParseServer(const char *paramP);
+  void ParsePortRange(const char *paramP);
  int ParseCicams(const char *valueP, int *cicamsP);
  int ParseSources(const char *valueP, int *sourcesP);
  int ParseFilters(const char *valueP, int *filtersP);
@@ -62,7 +64,7 @@ public:
  };

 cPluginSatip::cPluginSatip(void)
-: deviceCountM(1),
+: deviceCountM(2),
  serversM(NULL)
 {
  debug16("%s", __PRETTY_FUNCTION__);
@@ -83,10 +85,14 @@ const char *cPluginSatip::CommandLineHelp(void)
  // Return a string that describes all known command line options.
  return "  -d <num>, --devices=<number>  set number of devices to be created\n"
         "  -t <mode>, --trace=<mode>     set the tracing mode\n"
-         "  -s <ipaddr>|<model>|<desc>, --server=<ipaddr1>|<model1>|<desc1>;<ipaddr2>|<model2>|<desc2>\n"
+         "  -s <ipaddr>|<model>|<desc>, --server=<ipaddr1>|<model1>|<desc1>;<ipaddr2>:<port>|<model2>:<filter>|<desc2>:<quirk>\n"
         "                                define hard-coded SAT>IP server(s)\n"
+         "  -D, --detach                  set the detached mode on\n"
         "  -S, --single                  set the single model server mode on\n"
-         "  -n, --noquirks                disable all the server quirks\n";
+         "  -n, --noquirks                disable autodetection of the server quirks\n"
+         "  -p, --portrange=<start>-<end> set a range of ports used for the RT[C]P server\n"
+         "                                a minimum of 2 ports per device is required.\n"
+         "  -r, --rcvbuf                  override the size of the RTP receive buffer in bytes\n";
 }

 bool cPluginSatip::ProcessArgs(int argc, char *argv[])
@@ -97,14 +103,18 @@ bool cPluginSatip::ProcessArgs(int argc, char *argv[])
    { "devices",  required_argument, NULL, 'd' },
    { "trace",    required_argument, NULL, 't' },
    { "server",   required_argument, NULL, 's' },
+    { "portrange",required_argument, NULL, 'p' },
+    { "rcvbuf",   required_argument, NULL, 'r' },
+    { "detach",   no_argument,       NULL, 'D' },
    { "single",   no_argument,       NULL, 'S' },
    { "noquirks", no_argument,       NULL, 'n' },
    { NULL,       no_argument,       NULL,  0  }
    };

  cString server;
+  cString portrange;
  int c;
-  while ((c = getopt_long(argc, argv, "d:t:s:Sn", long_options, NULL)) != -1) {
+  while ((c = getopt_long(argc, argv, "d:t:s:p:r:DSn", long_options, NULL)) != -1) {
    switch (c) {
      case 'd':
           deviceCountM = strtol(optarg, NULL, 0);
@@ -115,16 +125,27 @@ bool cPluginSatip::ProcessArgs(int argc, char *argv[])
      case 's':
           server = optarg;
           break;
+      case 'D':
+           SatipConfig.SetDetachedMode(true);
+           break;
      case 'S':
           SatipConfig.SetUseSingleModelServers(true);
           break;
      case 'n':
           SatipConfig.SetDisableServerQuirks(true);
           break;
+      case 'p':
+           portrange = optarg;
+           break;
+      case 'r':
+           SatipConfig.SetRtpRcvBufSize(strtol(optarg, NULL, 0));
+           break;
      default:
           return false;
      }
    }
+  if (!isempty(*portrange))
+     ParsePortRange(portrange);
  // this must be done after all parameters are parsed
  if (!isempty(*server))
     ParseServer(*server);
@@ -217,7 +238,9 @@ void cPluginSatip::ParseServer(const char *paramP)
  while (r) {
        r = skipspace(r);
        debug3("%s server[%d]=%s", __PRETTY_FUNCTION__, n, r);
-        cString serverAddr, serverModel, serverDescription;
+        cString sourceAddr, serverAddr, serverModel, serverFilters, serverDescription;
+        int serverQuirk = cSatipServer::eSatipQuirkNone;
+        int serverPort = SATIP_DEFAULT_RTSP_PORT;
        int n2 = 0;
        char *s2, *p2 = r;
        char *r2 = strtok_r(p2, "|", &s2);
@@ -225,13 +248,40 @@ void cPluginSatip::ParseServer(const char *paramP)
              debug3("%s param[%d]=%s", __PRETTY_FUNCTION__, n2, r2);
              switch (n2++) {
                     case 0:
+                          {
+                          char *r3 = strchr(r2, '@');
+                          if (r3) {
+                             *r3 = 0;
+                             sourceAddr = r2;
+                             r2 = r3 + 1;
+                             }
                          serverAddr = r2;
+                          r3 = strchr(r2, ':');
+                          if (r3) {
+                             serverPort = strtol(r3 + 1, NULL, 0);
+                             serverAddr = serverAddr.Truncate(r3 - r2);
+                             }
+                          }
                          break;
                     case 1:
+                          {
                          serverModel = r2;
+                          char *r3 = strchr(r2, ':');
+                          if (r3) {
+                             serverFilters = r3 + 1;
+                             serverModel = serverModel.Truncate(r3 - r2);
+                             }
+                          }
                          break;
                     case 2:
+                          {
                          serverDescription = r2;
+                          char *r3 = strchr(r2, ':');
+                          if (r3) {
+                             serverQuirk = strtol(r3 + 1, NULL, 0);
+                             serverDescription = serverDescription.Truncate(r3 - r2);
+                             }
+                          }
                          break;
                     default:
                          break;
@@ -239,10 +289,10 @@ void cPluginSatip::ParseServer(const char *paramP)
              r2 = strtok_r(NULL, "|", &s2);
              }
        if (*serverAddr && *serverModel && *serverDescription) {
-           debug1("%s ipaddr=%s model=%s desc=%s", __PRETTY_FUNCTION__, *serverAddr, *serverModel, *serverDescription);
+           debug1("%s srcaddr=%s ipaddr=%s port=%d model=%s (%s) desc=%s (%d)", __PRETTY_FUNCTION__, *sourceAddr, *serverAddr, serverPort, *serverModel, *serverFilters, *serverDescription, serverQuirk);
           if (!serversM)
              serversM = new cSatipDiscoverServers();
-           serversM->Add(new cSatipDiscoverServer(*serverAddr, *serverModel, *serverDescription));
+           serversM->Add(new cSatipDiscoverServer(*sourceAddr, *serverAddr, serverPort, *serverModel, *serverFilters, *serverDescription, serverQuirk));
           }
        ++n;
        r = strtok_r(NULL, ";", &s);
@@ -250,6 +300,37 @@ void cPluginSatip::ParseServer(const char *paramP)
  FREE_POINTER(p);
 }

+void cPluginSatip::ParsePortRange(const char *paramP)
+{
+  char *s, *p = skipspace(paramP);
+  char *r = strtok_r(p, "-", &s);
+  unsigned int rangeStart = 0;
+  unsigned int rangeStop = 0;
+  if (r) {
+     rangeStart = strtol(r, NULL, 0);
+     r = strtok_r(NULL, "-", &s);
+     }
+  if (r)
+     rangeStop = strtol(r, NULL, 0);
+  else {
+     error("Port range argument not valid '%s'", paramP);
+     rangeStart = 0;
+     rangeStop = 0;
+     }
+  if (rangeStart % 2) {
+     error("The given range start port must be even!");
+     rangeStart = 0;
+     rangeStop = 0;
+     }
+  else if (rangeStop - rangeStart + 1 < deviceCountM * 2) {
+     error("The given port range is to small: %d < %d!", rangeStop - rangeStart + 1, deviceCountM * 2);
+     rangeStart = 0;
+     rangeStop = 0;
+     }
+  SatipConfig.SetPortRangeStart(rangeStart);
+  SatipConfig.SetPortRangeStop(rangeStop);
+}
+
 int cPluginSatip::ParseCicams(const char *valueP, int *cicamsP)
 {
  debug1("%s (%s,)", __PRETTY_FUNCTION__, valueP);
@@ -337,6 +418,8 @@ bool cPluginSatip::SetupParse(const char *nameP, const char *valueP)
     for (unsigned int i = 0; i < DisabledFiltersCount; ++i)
         SatipConfig.SetDisabledFilters(i, DisabledFilters[i]);
     }
+  else if (!strcasecmp(nameP, "TransportMode"))
+     SatipConfig.SetTransportMode(atoi(valueP));
  else
     return false;
  return true;
@@ -366,8 +449,12 @@ const char **cPluginSatip::SVDRPHelpPages(void)
    "    Lists status information of SAT>IP devices.\n",
    "CONT\n"
    "    Shows SAT>IP device count.\n",
-    "OPER\n"
-    "    Toggles operating mode of SAT>IP devices.\n",
+    "OPER [ off | low | normal | high ]\n"
+    "    Gets and(or sets operating mode of SAT>IP devices.\n",
+    "ATTA\n"
+    "    Attach active SAT>IP servers.\n",
+    "DETA\n"
+    "    Detachs active SAT>IP servers.\n",
    "TRAC [ <mode> ]\n"
    "    Gets and/or sets used tracing mode.\n",
    NULL
@@ -434,8 +521,19 @@ cString cPluginSatip::SVDRPCommand(const char *commandP, const char *optionP, in
     }
  else if (strcasecmp(commandP, "OPER") == 0) {
     cString mode;
-     SatipConfig.ToggleOperatingMode();
-     switch (SatipConfig.GetOperatingMode()) {
+     unsigned int oper = SatipConfig.GetOperatingMode();
+     if (optionP && *optionP) {
+        if (strcasecmp(optionP, "off") == 0)
+           oper = cSatipConfig::eOperatingModeOff;
+        else if (strcasecmp(optionP, "low") == 0)
+           oper = cSatipConfig::eOperatingModeLow;
+        else if (strcasecmp(optionP, "normal") == 0)
+           oper = cSatipConfig::eOperatingModeNormal;
+        else if (strcasecmp(optionP, "high") == 0)
+           oper = cSatipConfig::eOperatingModeHigh;
+        SatipConfig.SetOperatingMode(oper);
+     }
+     switch (oper) {
       case cSatipConfig::eOperatingModeOff:
            mode = "off";
            break;
@@ -454,6 +552,16 @@ cString cPluginSatip::SVDRPCommand(const char *commandP, const char *optionP, in
       }
     return cString::sprintf("SATIP operating mode: %s\n", *mode);
     }
+  else if (strcasecmp(commandP, "ATTA") == 0) {
+     SatipConfig.SetDetachedMode(false);
+     info("SATIP servers attached");
+     return cString("SATIP servers attached");
+     }
+  else if (strcasecmp(commandP, "DETA") == 0) {
+     SatipConfig.SetDetachedMode(true);
+     info("SATIP servers detached");
+     return cString("SATIP servers detached");
+     }
  else if (strcasecmp(commandP, "TRAC") == 0) {
     if (optionP && *optionP)
        SatipConfig.SetTraceMode(strtol(optionP, NULL, 0));
--- a/sectionfilter.c
+++ b/sectionfilter.c
@@ -102,8 +102,11 @@ int cSatipSectionFilter::Filter(void)
     if (doneqM && !neq)
        return 0;

-     if (ringBufferM && (secLenM > 0))
-        ringBufferM->Put(new cFrame(secBufM, secLenM));
+     if (ringBufferM && (secLenM > 0)) {
+        cFrame* section = new cFrame(secBufM, secLenM);
+        if (!ringBufferM->Put(section))
+           DELETE_POINTER(section);
+        }
     }
  return 0;
 }
@@ -126,7 +129,7 @@ int cSatipSectionFilter::CopyDump(const uint8_t *bufP, uint8_t lenP)
  if (tsFeedpM + lenP > eDmxMaxSectionFeedSize)
     lenP = (uint8_t)(eDmxMaxSectionFeedSize - tsFeedpM);

-  if (lenP <= 0)
+  if (lenP == 0)
     return 0;

  memcpy(secBufBaseM + tsFeedpM, bufP, lenP);
@@ -141,7 +144,7 @@ int cSatipSectionFilter::CopyDump(const uint8_t *bufP, uint8_t lenP)

  for (n = 0; secBufpM + 2 < limit; ++n) {
      uint16_t seclen = GetLength(secBufM);
-      if ((seclen <= 0) || (seclen > eDmxMaxSectionSize) || ((seclen + secBufpM) > limit))
+      if ((seclen > eDmxMaxSectionSize) || ((seclen + secBufpM) > limit))
         return 0;
      secLenM = seclen;
      if (pusiSeenM)
@@ -209,27 +212,28 @@ void cSatipSectionFilter::Process(const uint8_t* dataP)
     }
 }

-bool cSatipSectionFilter::Send(void)
+void cSatipSectionFilter::Send(void)
 {
-  bool result = false;
  cFrame *section = ringBufferM->Get();
  if (section) {
     uchar *data = section->Data();
     int count = section->Count();
     if (data && (count > 0) && (socketM[1] >= 0) && (socketM[0] >= 0)) {
-        ssize_t len = send(socketM[1], data, count, MSG_EOR);
-        ERROR_IF(len < 0 && errno != EAGAIN, "send()");
-        if (len > 0) {
-           ringBufferM->Drop(section);
-           result = !!ringBufferM->Available();
+        if (send(socketM[1], data, count, MSG_EOR) > 0) {
           // Update statistics
-           AddSectionStatistic(len, 1);
+           AddSectionStatistic(count, 1);
           }
+        else if (errno != EAGAIN)
+          error("failed to send section data (%i bytes) [device=%d]", count, deviceIndexM);
        }
+     ringBufferM->Drop(section);
     }
-  return result;
 }

+int cSatipSectionFilter::Available(void) const
+{
+  return ringBufferM->Available();
+}

 cSatipSectionFilterHandler::cSatipSectionFilterHandler(int deviceIndexP, unsigned int bufferLenP)
 : cThread(cString::sprintf("SATIP#%d section handler", deviceIndexP)),
@@ -267,54 +271,73 @@ cSatipSectionFilterHandler::~cSatipSectionFilterHandler()
      Delete(i);
 }

+void cSatipSectionFilterHandler::SendAll(void)
+{
+  cMutexLock MutexLock(&mutexM);
+  bool pendingData;
+  do {
+     pendingData = false;
+
+     // zero polling structures
+     memset(pollFdsM, 0, sizeof(pollFdsM));
+
+     // assemble all handlers to poll (use -1 to ignore handlers)
+     for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
+         if (filtersM[i] && filtersM[i]->Available() != 0) {
+            pollFdsM[i].fd = filtersM[i]->GetFd();
+            pollFdsM[i].events = POLLOUT;
+            pendingData = true;
+            }
+         else
+            pollFdsM[i].fd = -1;
+         }
+
+     // exit if there isn't any pending data or we time out
+     if (!pendingData || poll(pollFdsM, eMaxSecFilterCount, eSecFilterSendTimeoutMs) <= 0)
+        return;
+
+     // send data (if available)
+     for (unsigned int i = 0; i < eMaxSecFilterCount && pendingData; ++i) {
+         if (pollFdsM[i].revents & POLLOUT)
+            filtersM[i]->Send();
+         }
+  } while (pendingData);
+}
+
 void cSatipSectionFilterHandler::Action(void)
 {
  debug1("%s Entering [device %d]", __PRETTY_FUNCTION__, deviceIndexM);
-  bool processed = false;
  // Do the thread loop
  while (Running()) {
-        // Send demuxed section packets through all filters
-        bool retry = false;
-        mutexM.Lock();
-        for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
-            if (filtersM[i] && filtersM[i]->Send())
-               retry = true;
-            }
-        mutexM.Unlock();
-        if (retry)
-           continue;
-        // Read one TS packet
-        if (ringBufferM) {
-           int len = 0;
-           if (processed) {
-              ringBufferM->Del(TS_SIZE);
-              processed = false;
-              }
-           uchar *p = ringBufferM->Get(len);
-           if (p && (len >= TS_SIZE)) {
-              if (*p != TS_SYNC_BYTE) {
-                 for (int i = 1; i < len; ++i) {
-                     if (p[i] == TS_SYNC_BYTE) {
-                        len = i;
-                        break;
+        uchar *p = NULL;
+        int len = 0;
+        // Process all pending TS packets
+        while ((p  = ringBufferM->Get(len)) != NULL) {
+              if (p && (len >= TS_SIZE)) {
+                 if (*p != TS_SYNC_BYTE) {
+                    for (int i = 1; i < len; ++i) {
+                        if (p[i] == TS_SYNC_BYTE) {
+                           len = i;
+                           break;
+                           }
                        }
-                     }
-                 ringBufferM->Del(len);
-                 debug1("%s Skipped %d bytes to sync on TS packet [device %d]", __PRETTY_FUNCTION__, len, deviceIndexM);
-                 continue;
-                 }
-              // Process TS packet through all filters
-              mutexM.Lock();
-              for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
-                  if (filtersM[i])
-                     filtersM[i]->Process(p);
-                  }
-              mutexM.Unlock();
-              processed = true;
-              continue;
-              }
-           }
-        cCondWait::SleepMs(10); // to avoid busy loop and reduce cpu load
+                    ringBufferM->Del(len);
+                    debug1("%s Skipped %d bytes to sync on TS packet [device %d]", __PRETTY_FUNCTION__, len, deviceIndexM);
+                    continue;
+                    }
+                    // Process TS packet through all filters
+                    mutexM.Lock();
+                    for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
+                        if (filtersM[i])
+                           filtersM[i]->Process(p);
+                        }
+                    mutexM.Unlock();
+                    ringBufferM->Del(TS_SIZE);
+                    }
+                }
+
+        // Send demuxed section packets through all filters
+        SendAll();
        }
  debug1("%s Exiting [device %d]", __PRETTY_FUNCTION__, deviceIndexM);
 }
@@ -338,6 +361,19 @@ cString cSatipSectionFilterHandler::GetInformation(void)
  return s;
 }

+bool cSatipSectionFilterHandler::Exists(u_short pidP)
+{
+  debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, pidP, deviceIndexM);
+  cMutexLock MutexLock(&mutexM);
+  for (unsigned int i = 0; i < eMaxSecFilterCount; ++i) {
+      if (filtersM[i] && (pidP == filtersM[i]->GetPid())) {
+         debug12("%s (%d) Found [device %d]", __PRETTY_FUNCTION__, pidP, deviceIndexM);
+         return true;
+         }
+      }
+  return false;
+}
+
 bool cSatipSectionFilterHandler::Delete(unsigned int indexP)
 {
  debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, indexP, deviceIndexM);
--- a/sectionfilter.h
+++ b/sectionfilter.h
@@ -8,6 +8,7 @@
 #ifndef __SATIP_SECTIONFILTER_H
 #define __SATIP_SECTIONFILTER_H

+#include <poll.h>
 #include <vdr/device.h>

 #include "common.h"
@@ -55,23 +56,27 @@ public:
  cSatipSectionFilter(int deviceIndexP, uint16_t pidP, uint8_t tidP, uint8_t maskP);
  virtual ~cSatipSectionFilter();
  void Process(const uint8_t* dataP);
-  bool Send(void);
+  void Send(void);
  int GetFd(void) { return socketM[0]; }
  uint16_t GetPid(void) const { return pidM; }
+  int Available(void) const;
 };

 class cSatipSectionFilterHandler : public cThread {
 private:
  enum {
-    eMaxSecFilterCount = 32
+    eMaxSecFilterCount = 32,
+    eSecFilterSendTimeoutMs = 10
  };
  cRingBufferLinear *ringBufferM;
  cMutex mutexM;
  int deviceIndexM;
  cSatipSectionFilter *filtersM[eMaxSecFilterCount];
+  struct pollfd pollFdsM[eMaxSecFilterCount];

  bool Delete(unsigned int indexP);
  bool IsBlackListed(u_short pidP, u_char tidP, u_char maskP) const;
+  void SendAll(void);

 protected:
  virtual void Action(void);
@@ -80,6 +85,7 @@ public:
  cSatipSectionFilterHandler(int deviceIndexP, unsigned int bufferLenP);
  virtual ~cSatipSectionFilterHandler();
  cString GetInformation(void);
+  bool Exists(u_short pidP);
  int Open(u_short pidP, u_char tidP, u_char maskP);
  void Close(int handleP);
  int GetPid(int handleP);
--- a/server.c
+++ b/server.c
@@ -80,44 +80,105 @@ bool cSatipFrontends::Detach(int deviceIdP, int transponderP)

 // --- cSatipServer -----------------------------------------------------------

-cSatipServer::cSatipServer(const char *addressP, const char *modelP, const char *descriptionP)
-: addressM((addressP && *addressP) ? addressP : "0.0.0.0"),
+cSatipServer::cSatipServer(const char *srcAddressP, const char *addressP, const int portP, const char *modelP, const char *filtersP, const char *descriptionP, const int quirkP)
+: srcAddressM((srcAddressP && *srcAddressP) ? srcAddressP : ""),
+  addressM((addressP && *addressP) ? addressP : "0.0.0.0"),
  modelM((modelP && *modelP) ? modelP : "DVBS-1"),
+  filtersM((filtersP && *filtersP) ? filtersP : ""),
  descriptionM(!isempty(descriptionP) ? descriptionP : "MyBrokenHardware"),
  quirksM(""),
-  quirkM(eSatipQuirkNone),
+  portM(portP),
+  quirkM(quirkP),
  hasCiM(false),
+  activeM(true),
  createdM(time(NULL)),
  lastSeenM(0)
 {
+  memset(sourceFiltersM, 0, sizeof(sourceFiltersM));
+  if (!isempty(*filtersM)) {
+     char *s, *p = strdup(*filtersM);
+     char *r = strtok_r(p, ",", &s);
+     unsigned int i = 0;
+     while (r) {
+           int t = cSource::FromString(skipspace(r));
+           if (t && i < ELEMENTS(sourceFiltersM))
+              sourceFiltersM[i++] = t;
+           r = strtok_r(NULL, ",", &s);
+           }
+     if (i) {
+        filtersM = "";
+        for (unsigned int j = 0; j < i; ++j)
+            filtersM = cString::sprintf("%s%s%s", *filtersM, isempty(*filtersM) ? "" : ",", *cSource::ToString(sourceFiltersM[j]));
+        debug3("%s filters=%s", __PRETTY_FUNCTION__, *filtersM);
+        }
+     FREE_POINTER(p);
+     }
  if (!SatipConfig.GetDisableServerQuirks()) {
     // These devices contain a session id bug:
     // Inverto Airscreen Server IDL 400 ?
     // Elgato EyeTV Netstream 4Sat ?
-     if (strstr(*descriptionM, "GSSBOX") ||             // Grundig Sat Systems GSS.box DSI 400
-         strstr(*descriptionM, "DIGIBIT") ||            // Telestar Digibit R1
-         strstr(*descriptionM, "Triax SatIP Converter") // Triax TSS 400
-        ) {
+     if (strstr(*descriptionM, "GSSBOX") ||                    // Grundig Sat Systems GSS.box DSI 400
+         strstr(*descriptionM, "DIGIBIT") ||                   // Telestar Digibit R1
+         strstr(*descriptionM, "Triax SatIP Converter")        // Triax TSS 400
+        )
        quirkM |= eSatipQuirkSessionId;
-        quirksM = cString::sprintf("%s%sSessionId", *quirksM, isempty(*quirksM) ? "" : ",");
-        }
+     // These devices contain support for RTP over TCP:
+     if (strstr(*descriptionM, "minisatip") ||                 // minisatip server
+         strstr(*descriptionM, "DVBViewer")                    // DVBViewer Media Server
+        )
+        quirkM |= eSatipQuirkRtpOverTcp;
     // These devices contain a play (add/delpids) parameter bug:
-     if (strstr(*descriptionM, "fritzdvbc")             // Fritz!WLAN Repeater DVB-C
-        ) {
+     if (strstr(*descriptionM, "FRITZ!Box 6490 Cable") ||      // FRITZ!Box 6490 Cable
+         strstr(*descriptionM, "FRITZ!WLAN Repeater DVB-C") || // FRITZ!WLAN Repeater DVB-C
+         strstr(*descriptionM, "fritzdvbc")                    // FRITZ!WLAN Repeater DVB-C (old firmware)
+        )
        quirkM |= eSatipQuirkPlayPids;
-        quirksM = cString::sprintf("%s%sPlayPids", *quirksM, isempty(*quirksM) ? "" : ",");
-        }
     // These devices contain a frontend locking bug:
-     if (strstr(*descriptionM, "fritzdvbc")             // Fritz!WLAN Repeater DVB-C
-        ) {
+     if (strstr(*descriptionM, "FRITZ!Box 6490 Cable") ||      // FRITZ!Box 6490 Cable
+         strstr(*descriptionM, "FRITZ!WLAN Repeater DVB-C") || // FRITZ!WLAN Repeater DVB-C
+         strstr(*descriptionM, "fritzdvbc") ||                 // FRITZ!WLAN Repeater DVB-C (old firmware)
+         strstr(*descriptionM, "Schwaiger Sat>IP Server")      // Schwaiger MS41IP
+        )
        quirkM |= eSatipQuirkForceLock;
-        quirksM = cString::sprintf("%s%sForceLock", *quirksM, isempty(*quirksM) ? "" : ",");
-        }
-     debug3("%s description=%s quirks=%s", __PRETTY_FUNCTION__, *descriptionM, *quirksM);
+     // These devices support the X_PMT protocol extension
+     if (strstr(*descriptionM, "OctopusNet") ||                // Digital Devices OctopusNet
+         strstr(*descriptionM, "minisatip")                    // minisatip server
+        )
+        quirkM |= eSatipQuirkCiXpmt;
+     // These devices support the TNR protocol extension
+     if (strstr(*descriptionM, "DVBViewer")                    // DVBViewer Media Server
+        )
+        quirkM |= eSatipQuirkCiTnr;
+     // These devices don't support auto-detection of pilot tones
+     if (strstr(*descriptionM, "GSSBOX") ||                    // Grundig Sat Systems GSS.box DSI 400
+         strstr(*descriptionM, "DIGIBIT") ||                   // Telestar Digibit R1
+         strstr(*descriptionM, "Triax SatIP Converter") ||     // Triax TSS 400
+         strstr(*descriptionM, "KATHREIN SatIP Server")        // Kathrein ExIP 414/E
+        )
+        quirkM |= eSatipQuirkForcePilot;
     }
-  // These devices support the X_PMT protocol extension
-  if (strstr(*descriptionM, "OctopusNet"))              // Digital Devices OctopusNet
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkSessionId)
+     quirksM = cString::sprintf("%s%sSessionId", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkPlayPids)
+     quirksM = cString::sprintf("%s%sPlayPids", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkForceLock)
+     quirksM = cString::sprintf("%s%sForceLock", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkRtpOverTcp)
+     quirksM = cString::sprintf("%s%sRtpOverTcp", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkCiXpmt)
+     quirksM = cString::sprintf("%s%sCiXpmt", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkCiTnr)
+     quirksM = cString::sprintf("%s%sCiTnr", *quirksM, isempty(*quirksM) ? "" : ",");
+  if ((quirkM & eSatipQuirkMask) & eSatipQuirkForcePilot)
+     quirksM = cString::sprintf("%s%sForcePilot", *quirksM, isempty(*quirksM) ? "" : ",");
+  debug3("%s description=%s quirks=%s", __PRETTY_FUNCTION__, *descriptionM, *quirksM);
+  // These devices support external CI
+  if (strstr(*descriptionM, "OctopusNet") ||            // Digital Devices OctopusNet
+      strstr(*descriptionM, "minisatip") ||             // minisatip server
+      strstr(*descriptionM, "DVBViewer")                // DVBViewer Media Server
+     ) {
     hasCiM = true;
+     }
  char *s, *p = strdup(*modelM);
  char *r = strtok_r(p, ",", &s);
  while (r) {
@@ -149,7 +210,7 @@ cSatipServer::cSatipServer(const char *addressP, const char *modelP, const char
           }
        r = strtok_r(NULL, ",", &s);
        }
-  free(p);
+  FREE_POINTER(p);
 }

 cSatipServer::~cSatipServer()
@@ -168,53 +229,72 @@ int cSatipServer::Compare(const cListObject &listObjectP) const
  return result;
 }

+bool cSatipServer::IsValidSource(int sourceP)
+{
+  if (sourceFiltersM[0]) {
+     for (unsigned int i = 0; i < ELEMENTS(sourceFiltersM); ++i) {
+         if (sourceP == sourceFiltersM[i]) {
+            return true;
+            }
+         }
+     return false;
+     }
+  return true;
+}
+
 bool cSatipServer::Assign(int deviceIdP, int sourceP, int systemP, int transponderP)
 {
  bool result = false;
-  if (cSource::IsType(sourceP, 'S'))
-     result = frontendsM[eSatipFrontendDVBS2].Assign(deviceIdP, transponderP);
-  else if (cSource::IsType(sourceP, 'T')) {
-     if (systemP)
-        result = frontendsM[eSatipFrontendDVBT2].Assign(deviceIdP, transponderP);
-     else
-        result = frontendsM[eSatipFrontendDVBT].Assign(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBT2].Assign(deviceIdP, transponderP);
-     }
-  else if (cSource::IsType(sourceP, 'C')) {
-     if (systemP)
-        result = frontendsM[eSatipFrontendDVBC2].Assign(deviceIdP, transponderP);
-     else
-        result = frontendsM[eSatipFrontendDVBC].Assign(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBC2].Assign(deviceIdP, transponderP);
+  if (IsValidSource(sourceP)) {
+     if (cSource::IsType(sourceP, 'S'))
+        result = frontendsM[eSatipFrontendDVBS2].Assign(deviceIdP, transponderP);
+     else if (cSource::IsType(sourceP, 'T')) {
+        if (systemP)
+           result = frontendsM[eSatipFrontendDVBT2].Assign(deviceIdP, transponderP);
+        else
+           result = frontendsM[eSatipFrontendDVBT].Assign(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBT2].Assign(deviceIdP, transponderP);
+        }
+     else if (cSource::IsType(sourceP, 'C')) {
+        if (systemP)
+           result = frontendsM[eSatipFrontendDVBC2].Assign(deviceIdP, transponderP);
+        else
+           result = frontendsM[eSatipFrontendDVBC].Assign(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBC2].Assign(deviceIdP, transponderP);
+        }
     }
  return result;
 }

 bool cSatipServer::Matches(int sourceP)
 {
-  if (cSource::IsType(sourceP, 'S'))
-     return GetModulesDVBS2();
-  else if (cSource::IsType(sourceP, 'T'))
-     return GetModulesDVBT() || GetModulesDVBT2();
-  else if (cSource::IsType(sourceP, 'C'))
-     return GetModulesDVBC() || GetModulesDVBC2();
+  if (IsValidSource(sourceP)) {
+     if (cSource::IsType(sourceP, 'S'))
+        return GetModulesDVBS2();
+     else if (cSource::IsType(sourceP, 'T'))
+        return GetModulesDVBT() || GetModulesDVBT2();
+     else if (cSource::IsType(sourceP, 'C'))
+        return GetModulesDVBC() || GetModulesDVBC2();
+     }
  return false;
 }

 bool cSatipServer::Matches(int deviceIdP, int sourceP, int systemP, int transponderP)
 {
  bool result = false;
-  if (cSource::IsType(sourceP, 'S'))
-     result = frontendsM[eSatipFrontendDVBS2].Matches(deviceIdP, transponderP);
-  else if (cSource::IsType(sourceP, 'T')) {
-     if (systemP)
-        result = frontendsM[eSatipFrontendDVBT2].Matches(deviceIdP, transponderP);
-     else
-        result = frontendsM[eSatipFrontendDVBT].Matches(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBT2].Matches(deviceIdP, transponderP);
-     }
-  else if (cSource::IsType(sourceP, 'C')) {
-     if (systemP)
-        result = frontendsM[eSatipFrontendDVBC2].Matches(deviceIdP, transponderP);
-     else
-        result = frontendsM[eSatipFrontendDVBC].Matches(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBC2].Matches(deviceIdP, transponderP);
+  if (IsValidSource(sourceP)) {
+     if (cSource::IsType(sourceP, 'S'))
+        result = frontendsM[eSatipFrontendDVBS2].Matches(deviceIdP, transponderP);
+     else if (cSource::IsType(sourceP, 'T')) {
+        if (systemP)
+           result = frontendsM[eSatipFrontendDVBT2].Matches(deviceIdP, transponderP);
+        else
+           result = frontendsM[eSatipFrontendDVBT].Matches(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBT2].Matches(deviceIdP, transponderP);
+        }
+     else if (cSource::IsType(sourceP, 'C')) {
+        if (systemP)
+           result = frontendsM[eSatipFrontendDVBC2].Matches(deviceIdP, transponderP);
+        else
+           result = frontendsM[eSatipFrontendDVBC].Matches(deviceIdP, transponderP) || frontendsM[eSatipFrontendDVBC2].Matches(deviceIdP, transponderP);
+        }
     }
  return result;
 }
@@ -283,11 +363,11 @@ cSatipServer *cSatipServers::Find(int sourceP)
 cSatipServer *cSatipServers::Assign(int deviceIdP, int sourceP, int transponderP, int systemP)
 {
  for (cSatipServer *s = First(); s; s = Next(s)) {
-      if (s->Matches(deviceIdP, sourceP, systemP, transponderP))
+      if (s->IsActive() && s->Matches(deviceIdP, sourceP, systemP, transponderP))
         return s;
      }
  for (cSatipServer *s = First(); s; s = Next(s)) {
-      if (s->Assign(deviceIdP, sourceP, systemP, transponderP))
+      if (s->IsActive() && s->Assign(deviceIdP, sourceP, systemP, transponderP))
         return s;
      }
  return NULL;
@@ -304,6 +384,16 @@ cSatipServer *cSatipServers::Update(cSatipServer *serverP)
  return NULL;
 }

+void cSatipServers::Activate(cSatipServer *serverP, bool onOffP)
+{
+  for (cSatipServer *s = First(); s; s = Next(s)) {
+      if (s == serverP) {
+         s->Activate(onOffP);
+         break;
+         }
+      }
+}
+
 void cSatipServers::Attach(cSatipServer *serverP, int deviceIdP, int transponderP)
 {
  for (cSatipServer *s = First(); s; s = Next(s)) {
@@ -358,6 +448,18 @@ void cSatipServers::Cleanup(uint64_t intervalMsP)
      }
 }

+cString cSatipServers::GetSrcAddress(cSatipServer *serverP)
+{
+  cString address = "";
+  for (cSatipServer *s = First(); s; s = Next(s)) {
+      if (s == serverP) {
+         address = s->SrcAddress();
+         break;
+         }
+      }
+  return address;
+}
+
 cString cSatipServers::GetAddress(cSatipServer *serverP)
 {
  cString address = "";
@@ -370,6 +472,18 @@ cString cSatipServers::GetAddress(cSatipServer *serverP)
  return address;
 }

+int cSatipServers::GetPort(cSatipServer *serverP)
+{
+  int port = SATIP_DEFAULT_RTSP_PORT;
+  for (cSatipServer *s = First(); s; s = Next(s)) {
+      if (s == serverP) {
+         port = s->Port();
+         break;
+         }
+      }
+  return port;
+}
+
 cString cSatipServers::GetString(cSatipServer *serverP)
 {
  cString list = "";
@@ -386,7 +500,10 @@ cString cSatipServers::List(void)
 {
  cString list = "";
  for (cSatipServer *s = First(); s; s = Next(s))
-      list = cString::sprintf("%s%s|%s|%s\n", *list, s->Address(), s->Model(), s->Description());
+      if (isempty(s->SrcAddress()))
+         list = cString::sprintf("%s%c %s|%s|%s\n", *list, s->IsActive() ? '+' : '-', s->Address(), s->Model(), s->Description());
+      else
+         list = cString::sprintf("%s%c %s@%s|%s|%s\n", *list, s->IsActive() ? '+' : '-', s->SrcAddress(), s->Address(), s->Model(), s->Description());
  return list;
 }

--- a/server.h
+++ b/server.h
@@ -54,25 +54,38 @@ private:
    eSatipFrontendDVBC2,
    eSatipFrontendCount
  };
+  enum {
+    eSatipMaxSourceFilters = 16
+  };
+  cString srcAddressM;
  cString addressM;
  cString modelM;
+  cString filtersM;
  cString descriptionM;
  cString quirksM;
  cSatipFrontends frontendsM[eSatipFrontendCount];
+  int sourceFiltersM[eSatipMaxSourceFilters];
+  int portM;
  int quirkM;
  bool hasCiM;
+  bool activeM;
  time_t createdM;
  cTimeMs lastSeenM;
+  bool IsValidSource(int sourceP);

 public:
  enum eSatipQuirk {
-    eSatipQuirkNone      = 0x00,
-    eSatipQuirkSessionId = 0x01,
-    eSatipQuirkPlayPids  = 0x02,
-    eSatipQuirkForceLock = 0x04,
-    eSatipQuirkMask      = 0x0F
+    eSatipQuirkNone       = 0x00,
+    eSatipQuirkSessionId  = 0x01,
+    eSatipQuirkPlayPids   = 0x02,
+    eSatipQuirkForceLock  = 0x04,
+    eSatipQuirkRtpOverTcp = 0x08,
+    eSatipQuirkCiXpmt     = 0x10,
+    eSatipQuirkCiTnr      = 0x20,
+    eSatipQuirkForcePilot = 0x40,
+    eSatipQuirkMask       = 0xFF
  };
-  cSatipServer(const char *addressP, const char *modelP, const char *descriptionP);
+  cSatipServer(const char *srcAddressP, const char *addressP, const int portP, const char *modelP, const char *filtersP, const char *descriptionP, const int quirkP);
  virtual ~cSatipServer();
  virtual int Compare(const cListObject &listObjectP) const;
  bool Assign(int deviceIdP, int sourceP, int systemP, int transponderP);
@@ -85,13 +98,18 @@ public:
  int GetModulesDVBT2(void);
  int GetModulesDVBC(void);
  int GetModulesDVBC2(void);
+  void Activate(bool onOffP)    { activeM = onOffP; }
+  const char *SrcAddress(void)  { return *srcAddressM; }
  const char *Address(void)     { return *addressM; }
  const char *Model(void)       { return *modelM; }
+  const char *Filters(void)     { return *filtersM; }
  const char *Description(void) { return *descriptionM; }
  const char *Quirks(void)      { return *quirksM; }
+  int Port(void)                { return portM; }
  bool Quirk(int quirkP)        { return ((quirkP & eSatipQuirkMask) & quirkM); }
  bool HasQuirk(void)           { return (quirkM != eSatipQuirkNone); }
  bool HasCI(void)              { return hasCiM; }
+  bool IsActive(void)           { return activeM; }
  void Update(void)             { lastSeenM.Set(); }
  uint64_t LastSeen(void)       { return lastSeenM.Elapsed(); }
  time_t Created(void)          { return createdM; }
@@ -105,13 +123,16 @@ public:
  cSatipServer *Find(int sourceP);
  cSatipServer *Assign(int deviceIdP, int sourceP, int transponderP, int systemP);
  cSatipServer *Update(cSatipServer *serverP);
+  void Activate(cSatipServer *serverP, bool onOffP);
  void Attach(cSatipServer *serverP, int deviceIdP, int transponderP);
  void Detach(cSatipServer *serverP, int deviceIdP, int transponderP);
  bool IsQuirk(cSatipServer *serverP, int quirkP);
  bool HasCI(cSatipServer *serverP);
  void Cleanup(uint64_t intervalMsP = 0);
  cString GetAddress(cSatipServer *serverP);
+  cString GetSrcAddress(cSatipServer *serverP);
  cString GetString(cSatipServer *serverP);
+  int GetPort(cSatipServer *serverP);
  cString List(void);
  int NumProvidedSystems(void);
 };
--- a/setup.c
+++ b/setup.c
@@ -86,6 +86,8 @@ eOSState cSatipEditSrcItem::ProcessKey(eKeys Key)
 class cSatipServerInfo : public cOsdMenu
 {
 private:
+  cSatipServer *serverM;
+  int activeM;
  cString addressM;
  cString modelM;
  cString descriptionM;
@@ -94,14 +96,16 @@ private:
  void Setup(void);

 public:
-  cSatipServerInfo(cSatipServer *serverP);
+  explicit cSatipServerInfo(cSatipServer *serverP);
  virtual ~cSatipServerInfo();
  virtual eOSState ProcessKey(eKeys keyP);
 };

 cSatipServerInfo::cSatipServerInfo(cSatipServer *serverP)
 : cOsdMenu(tr("SAT>IP Server"), 20),
-  addressM(serverP ? serverP->Address() : "---"),
+  serverM(serverP),
+  activeM(serverP && serverP->IsActive()),
+  addressM(serverP ? (isempty(serverP->SrcAddress()) ? serverP->Address() : *cString::sprintf("%s@%s", serverP->SrcAddress(), serverP->Address())) : "---"),
  modelM(serverP ? serverP->Model() : "---"),
  descriptionM(serverP ? serverP->Description() : "---"),
  ciExtensionM(serverP && serverP->HasCI() ? trVDR("yes") : trVDR("no")),
@@ -118,6 +122,7 @@ cSatipServerInfo::~cSatipServerInfo()

 void cSatipServerInfo::Setup(void)
 {
+  Add(new cMenuEditBoolItem(trVDR("Active"), &activeM));
  Add(new cOsdItem(cString::sprintf("%s:\t%s", tr("Address"),       *addressM),              osUnknown, false));
  Add(new cOsdItem(cString::sprintf("%s:\t%s", tr("Model"),         *modelM),                osUnknown, false));
  Add(new cOsdItem(cString::sprintf("%s:\t%s", tr("Description"),   *descriptionM),          osUnknown, false));
@@ -127,6 +132,7 @@ void cSatipServerInfo::Setup(void)

 eOSState cSatipServerInfo::ProcessKey(eKeys keyP)
 {
+  int oldActive = activeM;
  eOSState state = cOsdMenu::ProcessKey(keyP);

  if (state == osUnknown) {
@@ -135,6 +141,12 @@ eOSState cSatipServerInfo::ProcessKey(eKeys keyP)
       default:  state = osContinue; break;
       }
     }
+
+  if (keyP != kNone && oldActive != activeM) {
+     cSatipDiscover::GetInstance()->ActivateServer(serverM, activeM);
+     Setup();
+     }
+
  return state;
 }

@@ -145,7 +157,7 @@ private:
  cSatipServer *serverM;

 public:
-  cSatipServerItem(cSatipServer *serverP);
+  explicit cSatipServerItem(cSatipServer *serverP);
  cSatipServer *Server(void) { return serverM; }
  virtual void SetMenuItem(cSkinDisplayMenu *displayMenuP, int indexP, bool currentP, bool selectableP);
  };
@@ -155,7 +167,7 @@ cSatipServerItem::cSatipServerItem(cSatipServer *serverP)
 {
  SetSelectable(true);
  // Must begin with a '#' character!
-  SetText(*cString::sprintf("# %s (%s)\t%s", serverM->Address(), serverM->Model(), serverM->Description()));
+  SetText(*cString::sprintf("%s %s (%s)\t%s", serverM->IsActive() ? "+" : "-", isempty(serverM->SrcAddress()) ? serverM->Address() : *cString::sprintf("%s@%s", serverM->SrcAddress(), serverM->Address()), serverM->Model(), serverM->Description()));
 }

 void cSatipServerItem::SetMenuItem(cSkinDisplayMenu *displayMenuP, int indexP, bool currentP, bool selectableP)
@@ -330,8 +342,10 @@ eOSState cSatipMenuInfo::ProcessKey(eKeys keyP)
 // --- cSatipPluginSetup ------------------------------------------------------

 cSatipPluginSetup::cSatipPluginSetup()
-: deviceCountM(0),
+: detachedModeM(SatipConfig.GetDetachedMode()),
+  deviceCountM(0),
  operatingModeM(SatipConfig.GetOperatingMode()),
+  transportModeM(SatipConfig.GetTransportMode()),
  ciExtensionM(SatipConfig.GetCIExtension()),
  eitScanM(SatipConfig.GetEITScan()),
  numDisabledSourcesM(SatipConfig.GetDisabledSourcesCount()),
@@ -342,6 +356,9 @@ cSatipPluginSetup::cSatipPluginSetup()
  operatingModeTextsM[cSatipConfig::eOperatingModeLow]    = tr("low");
  operatingModeTextsM[cSatipConfig::eOperatingModeNormal] = tr("normal");
  operatingModeTextsM[cSatipConfig::eOperatingModeHigh]   = tr("high");
+  transportModeTextsM[cSatipConfig::eTransportModeUnicast]    = tr("Unicast");
+  transportModeTextsM[cSatipConfig::eTransportModeMulticast]  = tr("Multicast");
+  transportModeTextsM[cSatipConfig::eTransportModeRtpOverTcp] = tr("RTP-over-TCP");
  for (unsigned int i = 0; i < ELEMENTS(cicamsM); ++i)
      cicamsM[i] = SatipConfig.GetCICAM(i);
  for (unsigned int i = 0; i < ELEMENTS(ca_systems_table); ++i)
@@ -399,15 +416,20 @@ void cSatipPluginSetup::Setup(void)
         helpM.Append(tr("Define an ill-behaving filter to be blacklisted."));
         }
     }
+  Add(new cMenuEditStraItem(tr("Transport mode"), &transportModeM, ELEMENTS(transportModeTextsM), transportModeTextsM));
+  helpM.Append(tr("Define which transport mode shall be used.\n\nUnicast, Multicast, RTP-over-TCP"));
  Add(new cOsdItem(tr("Active SAT>IP servers:"), osUnknown, false));
  helpM.Append("");

-  cSatipServers *servers = cSatipDiscover::GetInstance()->GetServers();
-  deviceCountM = servers->Count();
-  for (cSatipServer *s = servers->First(); s; s = servers->Next(s)) {
-      Add(new cSatipServerItem(s));
-      helpM.Append("");
-      }
+  detachedModeM = SatipConfig.GetDetachedMode();
+  if (!detachedModeM) {
+     cSatipServers *servers = cSatipDiscover::GetInstance()->GetServers();
+     deviceCountM = servers->Count();
+     for (cSatipServer *s = servers->First(); s; s = servers->Next(s)) {
+         Add(new cSatipServerItem(s));
+         helpM.Append("");
+         }
+     }

  SetCurrent(Get(current));
  Display();
@@ -461,10 +483,12 @@ eOSState cSatipPluginSetup::ProcessKey(eKeys keyP)
  int oldNumDisabledFilters = numDisabledFiltersM;
  eOSState state = cMenuSetupPage::ProcessKey(keyP);

-  // Ugly hack with hardcoded '#' character :(
+  // Ugly hack with hardcoded '+/-' characters :(
  const char *p = Get(Current())->Text();
-  if (!hadSubMenu && !HasSubMenu() && (*p == '#') && (keyP == kOk))
+  if (!hadSubMenu && !HasSubMenu() && p && (*p == '+' || *p == '-') && (keyP == kOk))
     return DeviceInfo();
+  if (hadSubMenu && !HasSubMenu())
+     Setup();

  if (state == osUnknown) {
     switch (keyP) {
@@ -480,7 +504,7 @@ eOSState cSatipPluginSetup::ProcessKey(eKeys keyP)
  if ((keyP == kNone) && (cSatipDiscover::GetInstance()->GetServers()->Count() != deviceCountM))
     Setup();

-  if ((keyP != kNone) && ((numDisabledSourcesM != oldNumDisabledSources) || (numDisabledFiltersM != oldNumDisabledFilters) || (operatingModeM != oldOperatingMode) || (ciExtensionM != oldCiExtension))) {
+  if ((keyP != kNone) && ((numDisabledSourcesM != oldNumDisabledSources) || (numDisabledFiltersM != oldNumDisabledFilters) || (operatingModeM != oldOperatingMode) || (ciExtensionM != oldCiExtension) || (detachedModeM != SatipConfig.GetDetachedMode()))) {
     while ((numDisabledSourcesM < oldNumDisabledSources) && (oldNumDisabledSources > 0))
           disabledSourcesM[--oldNumDisabledSources] = cSource::stNone;
     while ((numDisabledFiltersM < oldNumDisabledFilters) && (oldNumDisabledFilters > 0))
@@ -543,6 +567,7 @@ void cSatipPluginSetup::Store(void)
 {
  // Store values into setup.conf
  SetupStore("OperatingMode", operatingModeM);
+  SetupStore("TransportMode", transportModeM);
  SetupStore("EnableCIExtension", ciExtensionM);
  SetupStore("EnableEITScan", eitScanM);
  StoreCicams("CICAM", cicamsM);
@@ -550,6 +575,7 @@ void cSatipPluginSetup::Store(void)
  StoreFilters("DisabledFilters", disabledFilterIndexesM);
  // Update global config
  SatipConfig.SetOperatingMode(operatingModeM);
+  SatipConfig.SetTransportMode(transportModeM);
  SatipConfig.SetCIExtension(ciExtensionM);
  SatipConfig.SetEITScan(eitScanM);
  for (int i = 0; i < MAX_CICAM_COUNT; ++i)
--- a/setup.h
+++ b/setup.h
@@ -15,9 +15,12 @@
 class cSatipPluginSetup : public cMenuSetupPage
 {
 private:
+  bool detachedModeM;
  int deviceCountM;
  int operatingModeM;
+  int transportModeM;
  const char *operatingModeTextsM[cSatipConfig::eOperatingModeCount];
+  const char *transportModeTextsM[cSatipConfig::eTransportModeCount];
  int ciExtensionM;
  int cicamsM[MAX_CICAM_COUNT];
  const char *cicamTextsM[CA_SYSTEMS_TABLE_SIZE];
--- a/socket.c
+++ b/socket.c
@@ -19,9 +19,35 @@
 #include "log.h"
 #include "socket.h"

+#if defined(__GLIBC__)
+  #if defined(__GLIBC_PREREQ)
+    #if !__GLIBC_PREREQ(2,12)
+      #define __SATIP_DISABLE_RECVMMSG__
+    #endif
+  #endif
+#endif
+
 cSatipSocket::cSatipSocket()
 : socketPortM(0),
-  socketDescM(-1)
+  socketDescM(-1),
+  isMulticastM(false),
+  useSsmM(false),
+  streamAddrM(htonl(INADDR_ANY)),
+  sourceAddrM(htonl(INADDR_ANY)),
+  rcvBufSizeM(0)
+{
+  debug1("%s", __PRETTY_FUNCTION__);
+  memset(&sockAddrM, 0, sizeof(sockAddrM));
+}
+
+cSatipSocket::cSatipSocket(size_t rcvBufSizeP)
+: socketPortM(0),
+  socketDescM(-1),
+  isMulticastM(false),
+  useSsmM(false),
+  streamAddrM(htonl(INADDR_ANY)),
+  sourceAddrM(htonl(INADDR_ANY)),
+  rcvBufSizeM(rcvBufSizeP)
 {
  debug1("%s", __PRETTY_FUNCTION__);
  memset(&sockAddrM, 0, sizeof(sockAddrM));
@@ -34,10 +60,17 @@ cSatipSocket::~cSatipSocket()
  Close();
 }

-bool cSatipSocket::Open(const int portP)
+bool cSatipSocket::Open(const int portP, const bool reuseP)
 {
+  // If socket is there already and it is bound to a different port, it must
+  // be closed first
+  if (portP != socketPortM) {
+     debug1("%s (%d, %d) Socket tear-down", __PRETTY_FUNCTION__, portP, reuseP);
+     Close();
+     }
  // Bind to the socket if it is not active already
  if (socketDescM < 0) {
+     int yes;
     socklen_t len = sizeof(sockAddrM);
     // Create socket
     socketDescM = socket(PF_INET, SOCK_DGRAM, 0);
@@ -46,9 +79,24 @@ bool cSatipSocket::Open(const int portP)
     ERROR_IF_FUNC(fcntl(socketDescM, F_SETFL, O_NONBLOCK), "fcntl(O_NONBLOCK)",
                   Close(), return false);
     // Allow multiple sockets to use the same PORT number
-     int yes = 1;
+     yes = reuseP;
     ERROR_IF_FUNC(setsockopt(socketDescM, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0,
                   "setsockopt(SO_REUSEADDR)", Close(), return false);
+     yes = reuseP;
+#ifdef SO_REUSEPORT
+     ERROR_IF_FUNC(setsockopt(socketDescM, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes)) < 0 && errno != ENOPROTOOPT,
+                   "setsockopt(SO_REUSEPORT)", Close(), return false);
+#endif
+#ifndef __FreeBSD__
+     // Allow packet information to be fetched
+     ERROR_IF_FUNC(setsockopt(socketDescM, SOL_IP, IP_PKTINFO, &yes, sizeof(yes)) < 0,
+                   "setsockopt(IP_PKTINFO)", Close(), return false);
+#endif // __FreeBSD__
+     // Tweak receive buffer size if requested
+     if (rcvBufSizeM > 0) {
+        ERROR_IF_FUNC(setsockopt(socketDescM, SOL_SOCKET, SO_RCVBUF, &rcvBufSizeM, sizeof(rcvBufSizeM)) < 0,
+                      "setsockopt(SO_RCVBUF)", Close(), return false);
+     }
     // Bind socket
     memset(&sockAddrM, 0, sizeof(sockAddrM));
     sockAddrM.sin_family = AF_INET;
@@ -57,23 +105,41 @@ bool cSatipSocket::Open(const int portP)
     ERROR_IF_FUNC(bind(socketDescM, (struct sockaddr *)&sockAddrM, sizeof(sockAddrM)) < 0,
                   "bind()", Close(), return false);
     // Update socket port
-     ERROR_IF_FUNC(getsockname(socketDescM,(struct sockaddr*)&sockAddrM, &len) < 0,
+     ERROR_IF_FUNC(getsockname(socketDescM, (struct sockaddr*)&sockAddrM, &len) < 0,
                   "getsockname()", Close(), return false);
     socketPortM = ntohs(sockAddrM.sin_port);
+     isMulticastM = false;
     }
  debug1("%s (%d) socketPort=%d", __PRETTY_FUNCTION__, portP, socketPortM);
  return true;
 }

+bool cSatipSocket::OpenMulticast(const int portP, const char *streamAddrP, const char *sourceAddrP)
+{
+  debug1("%s (%d, %s, %s)", __PRETTY_FUNCTION__, portP, streamAddrP, sourceAddrP);
+  if (Open(portP)) {
+     CheckAddress(streamAddrP, &streamAddrM);
+     if (!isempty(sourceAddrP))
+        useSsmM = CheckAddress(sourceAddrP, &sourceAddrM);
+     return Join();
+     }
+  return false;
+}
+
 void cSatipSocket::Close(void)
 {
-  debug1("%s sockerPort=%d", __PRETTY_FUNCTION__, socketPortM);
+  debug1("%s socketPort=%d", __PRETTY_FUNCTION__, socketPortM);
  // Check if socket exists
  if (socketDescM >= 0) {
+     Leave();
     close(socketDescM);
     socketDescM = -1;
     socketPortM = 0;
     memset(&sockAddrM, 0, sizeof(sockAddrM));
+     streamAddrM = htonl(INADDR_ANY);
+     sourceAddrM = htonl(INADDR_ANY);
+     isMulticastM = false;
+     useSsmM = false;
     }
 }

@@ -96,6 +162,96 @@ bool cSatipSocket::Flush(void)
  return false;
 }

+bool cSatipSocket::CheckAddress(const char *addrP, in_addr_t *inAddrP)
+{
+  if (inAddrP) {
+     // First try only the IP address
+     *inAddrP = inet_addr(addrP);
+     if (*inAddrP == htonl(INADDR_NONE)) {
+        debug1("%s (%s, ) Cannot convert to address", __PRETTY_FUNCTION__, addrP);
+        // It may be a host name, get the name
+        struct hostent *host = gethostbyname(addrP);
+        if (!host) {
+           char tmp[64];
+           error("gethostbyname() failed: %s is not valid address: %s", addrP,
+                 strerror_r(h_errno, tmp, sizeof(tmp)));
+           return false;
+           }
+        *inAddrP = inet_addr(*host->h_addr_list);
+        }
+     return true;
+     }
+  return false;
+}
+
+bool cSatipSocket::Join(void)
+{
+  debug1("%s", __PRETTY_FUNCTION__);
+  // Check if socket exists
+  if (socketDescM >= 0 && !isMulticastM) {
+     // Join a new multicast group
+     if (useSsmM) {
+        // Source-specific multicast (SSM) is used
+        struct group_source_req gsr;
+        struct sockaddr_in *grp;
+        struct sockaddr_in *src;
+        gsr.gsr_interface = 0; // if_nametoindex("any") ?
+        grp = (struct sockaddr_in*)&gsr.gsr_group;
+        grp->sin_family = AF_INET;
+        grp->sin_addr.s_addr = streamAddrM;
+        grp->sin_port = 0;
+        src = (struct sockaddr_in*)&gsr.gsr_source;
+        src->sin_family = AF_INET;
+        src->sin_addr.s_addr = sourceAddrM;
+        src->sin_port = 0;
+        ERROR_IF_RET(setsockopt(socketDescM, SOL_IP, MCAST_JOIN_SOURCE_GROUP, &gsr, sizeof(gsr)) < 0, "setsockopt(MCAST_JOIN_SOURCE_GROUP)", return false);
+        }
+     else {
+        struct ip_mreq mreq;
+        mreq.imr_multiaddr.s_addr = streamAddrM;
+        mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+        ERROR_IF_RET(setsockopt(socketDescM, SOL_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0, "setsockopt(IP_ADD_MEMBERSHIP)", return false);
+        }
+     // Update multicasting flag
+     isMulticastM = true;
+     }
+  return true;
+}
+
+bool cSatipSocket::Leave(void)
+{
+  debug1("%s", __PRETTY_FUNCTION__);
+  // Check if socket exists
+  if (socketDescM >= 0 && isMulticastM) {
+     // Leave the existing multicast group
+     if (useSsmM) {
+        // Source-specific multicast (SSM) is used
+        struct group_source_req gsr;
+        struct sockaddr_in *grp;
+        struct sockaddr_in *src;
+        gsr.gsr_interface = 0; // if_nametoindex("any") ?
+        grp = (struct sockaddr_in*)&gsr.gsr_group;
+        grp->sin_family = AF_INET;
+        grp->sin_addr.s_addr = streamAddrM;
+        grp->sin_port = 0;
+        src = (struct sockaddr_in*)&gsr.gsr_source;
+        src->sin_family = AF_INET;
+        src->sin_addr.s_addr = sourceAddrM;
+        src->sin_port = 0;
+        ERROR_IF_RET(setsockopt(socketDescM, SOL_IP, MCAST_LEAVE_SOURCE_GROUP, &gsr, sizeof(gsr)) < 0, "setsockopt(MCAST_LEAVE_SOURCE_GROUP)", return false);
+        }
+     else {
+        struct ip_mreq mreq;
+        mreq.imr_multiaddr.s_addr = streamAddrM;
+        mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+        ERROR_IF_RET(setsockopt(socketDescM, SOL_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) < 0, "setsockopt(IP_DROP_MEMBERSHIP)", return false);
+        }
+     // Update multicasting flag
+     isMulticastM = false;
+     }
+  return true;
+}
+
 int cSatipSocket::Read(unsigned char *bufferAddrP, unsigned int bufferLenP)
 {
  debug16("%s (, %d)", __PRETTY_FUNCTION__, bufferLenP);
@@ -126,8 +282,22 @@ int cSatipSocket::Read(unsigned char *bufferAddrP, unsigned int bufferLenP)

    if (socketDescM && bufferAddrP && (bufferLenP > 0))
       len = (int)recvmsg(socketDescM, &msgh, MSG_DONTWAIT);
-    if (len > 0)
-       return len;
+    if (len > 0) {
+#ifndef __FreeBSD__
+       if (isMulticastM) {
+          // Process auxiliary received data and validate source address
+          for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh); cmsg != NULL; cmsg = CMSG_NXTHDR(&msgh, cmsg)) {
+              if ((cmsg->cmsg_level == SOL_IP) && (cmsg->cmsg_type == IP_PKTINFO)) {
+                 struct in_pktinfo *i = (struct in_pktinfo *)CMSG_DATA(cmsg);
+                 if ((i->ipi_addr.s_addr == streamAddrM) || (htonl(INADDR_ANY) == streamAddrM))
+                    return len;
+                 }
+              }
+          }
+       else
+#endif // __FreeBSD__
+          return len;
+       }
    } while (len > 0);
  ERROR_IF_RET(len < 0 && errno != EAGAIN && errno != EWOULDBLOCK, "recvmsg()", return -1);
  return 0;
@@ -146,7 +316,7 @@ int cSatipSocket::ReadMulti(unsigned char *bufferAddrP, unsigned int *elementRec
     error("%s Invalid parameter(s)", __PRETTY_FUNCTION__);
     return -1;
     }
-#if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2,12)
+#ifndef __SATIP_DISABLE_RECVMMSG__
  // Initialize iov and msgh structures
  struct mmsghdr mmsgh[elementCountP];
  struct iovec iov[elementCountP];
--- a/socket.h
+++ b/socket.h
@@ -15,14 +15,26 @@ private:
  int socketPortM;
  int socketDescM;
  struct sockaddr_in sockAddrM;
+  bool isMulticastM;
+  bool useSsmM;
+  in_addr_t streamAddrM;
+  in_addr_t sourceAddrM;
+  size_t rcvBufSizeM;
+
+  bool CheckAddress(const char *addrP, in_addr_t *inAddrP);
+  bool Join(void);
+  bool Leave(void);

 public:
  cSatipSocket();
+  explicit cSatipSocket(size_t rcvBufSizeP);
  virtual ~cSatipSocket();
-  bool Open(const int portP = 0);
+  bool Open(const int portP = 0, const bool reuseP = false);
+  bool OpenMulticast(const int portP, const char *streamAddrP, const char *sourceAddrP);
  virtual void Close(void);
  int Fd(void) { return socketDescM; }
  int Port(void) { return socketPortM; }
+  bool IsMulticast(void) { return isMulticastM; }
  bool IsOpen(void) { return (socketDescM >= 0); }
  bool Flush(void);
  int Read(unsigned char *bufferAddrP, unsigned int bufferLenP);
--- a/tuner.c
+++ b/tuner.c
@@ -25,6 +25,8 @@ cSatipTuner::cSatipTuner(cSatipDeviceIf &deviceP, unsigned int packetLenP)
  rtcpM(*this),
  streamAddrM(""),
  streamParamM(""),
+  tnrParamM(""),
+  streamPortM(SATIP_DEFAULT_RTSP_PORT),
  currentServerM(NULL, deviceP.GetId(), 0),
  nextServerM(NULL, deviceP.GetId(), 0),
  mutexM(),
@@ -50,12 +52,16 @@ cSatipTuner::cSatipTuner(cSatipDeviceIf &deviceP, unsigned int packetLenP)
  debug1("%s (, %d) [device %d]", __PRETTY_FUNCTION__, packetLenP, deviceIdM);

  // Open sockets
-  int i = 100;
+  int i = SatipConfig.GetPortRangeStart() ? SatipConfig.GetPortRangeStop() - SatipConfig.GetPortRangeStart() - 1 : 100;
+  int port = SatipConfig.GetPortRangeStart();
  while (i-- > 0) {
-        if (rtpM.Open(0) && rtcpM.Open(rtpM.Port() + 1))
+        // RTP must use an even port number
+        if (rtpM.Open(port) && (rtpM.Port() % 2 == 0) && rtcpM.Open(rtpM.Port() + 1))
           break;
        rtpM.Close();
        rtcpM.Close();
+        if (SatipConfig.GetPortRangeStart())
+           port += 2;
        }
  if ((rtpM.Port() <= 0) || (rtcpM.Port() <= 0)) {
     error("Cannot open required RTP/RTCP ports [device %d]", deviceIdM);
@@ -91,6 +97,10 @@ cSatipTuner::~cSatipTuner()
 void cSatipTuner::Action(void)
 {
  debug1("%s Entering [device %d]", __PRETTY_FUNCTION__, deviceIdM);
+
+  bool lastIdleStatus = false;
+  cTimeMs idleCheck(eIdleCheckTimeoutMs);
+  cTimeMs tuning(eTuningTimeoutMs);
  reConnectM.Set(eConnectTimeoutMs);
  // Do the thread loop
  while (Running()) {
@@ -107,6 +117,7 @@ void cSatipTuner::Action(void)
          case tsSet:
               debug4("%s: tsSet [device %d]", __PRETTY_FUNCTION__, deviceIdM);
               if (Connect()) {
+                  tuning.Set(eTuningTimeoutMs);
                  RequestState(tsTuned, smInternal);
                  UpdatePids(true);
                  }
@@ -115,7 +126,10 @@ void cSatipTuner::Action(void)
               break;
          case tsTuned:
               debug4("%s: tsTuned [device %d]", __PRETTY_FUNCTION__, deviceIdM);
+               deviceM->SetChannelTuned();
               reConnectM.Set(eConnectTimeoutMs);
+               idleCheck.Set(eIdleCheckTimeoutMs);
+               lastIdleStatus = false;
               // Read reception statistics via DESCRIBE and RTCP
               if (hasLockM || ReadReceptionStatus()) {
                  // Quirk for devices without valid reception data
@@ -127,6 +141,10 @@ void cSatipTuner::Action(void)
                  if (hasLockM)
                     RequestState(tsLocked, smInternal);
                  }
+               else if (tuning.TimedOut()) {
+                  error("Tuning timeout - retuning [device %d]", deviceIdM);
+                  RequestState(tsSet, smInternal);
+                  }
               break;
          case tsLocked:
               debug4("%s: tsLocked [device %d]", __PRETTY_FUNCTION__, deviceIdM);
@@ -145,6 +163,16 @@ void cSatipTuner::Action(void)
                  RequestState(tsSet, smInternal);
                  break;
                  }
+               if (idleCheck.TimedOut()) {
+                  bool currentIdleStatus = deviceM->IsIdle();
+                  if (lastIdleStatus && currentIdleStatus) {
+                     info("Idle timeout - releasing [device %d]", deviceIdM);
+                     RequestState(tsRelease, smInternal);
+                     }
+                  lastIdleStatus = currentIdleStatus;
+                  idleCheck.Set(eIdleCheckTimeoutMs);
+                  break;
+                  }
               break;
          default:
               error("Unknown tuner status %d [device %d]", currentStateM, deviceIdM);
@@ -184,7 +212,8 @@ bool cSatipTuner::Connect(void)
  debug1("%s [device %d]", __PRETTY_FUNCTION__, deviceIdM);

  if (!isempty(*streamAddrM)) {
-     cString connectionUri = cString::sprintf("rtsp://%s/", *streamAddrM);
+     cString connectionUri = GetBaseUrl(*streamAddrM, streamPortM);
+     tnrParamM = "";
     // Just retune
     if (streamIdM >= 0) {
        cString uri = cString::sprintf("%sstream=%d?%s", *connectionUri, streamIdM, *streamParamM);
@@ -194,12 +223,15 @@ bool cSatipTuner::Connect(void)
           return true;
           }
        }
-     else if (rtspM.Options(*connectionUri)) {
+     else if (rtspM.SetInterface(nextServerM.IsValid() ? *nextServerM.GetSrcAddress() : NULL) && rtspM.Options(*connectionUri)) {
        cString uri = cString::sprintf("%s?%s", *connectionUri, *streamParamM);
+        bool useTcp = SatipConfig.IsTransportModeRtpOverTcp() && nextServerM.IsValid() && nextServerM.IsQuirk(cSatipServer::eSatipQuirkRtpOverTcp);
        // Flush any old content
        //rtpM.Flush();
        //rtcpM.Flush();
-        if (rtspM.Setup(*uri, rtpM.Port(), rtcpM.Port())) {
+        if (useTcp)
+           debug1("%s Requesting TCP [device %d]", __PRETTY_FUNCTION__, deviceIdM);
+        if (rtspM.Setup(*uri, rtpM.Port(), rtcpM.Port(), useTcp)) {
           keepAliveM.Set(timeoutM);
           if (nextServerM.IsValid()) {
              currentServerM = nextServerM;
@@ -209,8 +241,7 @@ bool cSatipTuner::Connect(void)
           return true;
           }
        }
-     else
-        rtspM.Reset();
+     rtspM.Reset();
     streamIdM = -1;
     error("Connect failed [device %d]", deviceIdM);
     }
@@ -224,7 +255,7 @@ bool cSatipTuner::Disconnect(void)
  debug1("%s [device %d]", __PRETTY_FUNCTION__, deviceIdM);

  if (!isempty(*streamAddrM) && (streamIdM >= 0)) {
-     cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
+     cString uri = cString::sprintf("%sstream=%d", *GetBaseUrl(*streamAddrM, streamPortM), streamIdM);
     rtspM.Teardown(*uri);
     // some devices requires a teardown for TCP connection also
     rtspM.Reset();
@@ -269,6 +300,11 @@ void cSatipTuner::ProcessVideoData(u_char *bufferP, int lengthP)
  reConnectM.Set(eConnectTimeoutMs);
 }

+void cSatipTuner::ProcessRtpData(u_char *bufferP, int lengthP)
+{
+  rtpM.Process(bufferP, lengthP);
+}
+
 void cSatipTuner::ProcessApplicationData(u_char *bufferP, int lengthP)
 {
  debug16("%s (%d) [device %d]", __PRETTY_FUNCTION__, lengthP, deviceIdM);
@@ -322,6 +358,11 @@ void cSatipTuner::ProcessApplicationData(u_char *bufferP, int lengthP)
  reConnectM.Set(eConnectTimeoutMs);
 }

+void cSatipTuner::ProcessRtcpData(u_char *bufferP, int lengthP)
+{
+  rtcpM.Process(bufferP, lengthP);
+}
+
 void cSatipTuner::SetStreamId(int streamIdP)
 {
  cMutexLock MutexLock(&mutexM);
@@ -339,6 +380,47 @@ void cSatipTuner::SetSessionTimeout(const char *sessionP, int timeoutP)
  timeoutM = (timeoutP > eMinKeepAliveIntervalMs) ? timeoutP : eMinKeepAliveIntervalMs;
 }

+void cSatipTuner::SetupTransport(int rtpPortP, int rtcpPortP, const char *streamAddrP, const char *sourceAddrP)
+{
+  cMutexLock MutexLock(&mutexM);
+  debug1("%s (%d, %d, %s, %s) [device %d]", __PRETTY_FUNCTION__, rtpPortP, rtcpPortP, streamAddrP, sourceAddrP, deviceIdM);
+  bool multicast = !isempty(streamAddrP);
+  // Adapt RTP to any transport media change
+  if (multicast != rtpM.IsMulticast() || rtpPortP != rtpM.Port()) {
+     cSatipPoller::GetInstance()->Unregister(rtpM);
+     if (rtpPortP >= 0) {
+        rtpM.Close();
+        if (multicast)
+           rtpM.OpenMulticast(rtpPortP, streamAddrP, sourceAddrP);
+        else
+           rtpM.Open(rtpPortP);
+        cSatipPoller::GetInstance()->Register(rtpM);
+        }
+     }
+  // Adapt RTCP to any transport media change
+  if (multicast != rtcpM.IsMulticast() || rtcpPortP != rtcpM.Port()) {
+     cSatipPoller::GetInstance()->Unregister(rtcpM);
+     if (rtcpPortP >= 0) {
+        rtcpM.Close();
+        if (multicast)
+           rtcpM.OpenMulticast(rtcpPortP, streamAddrP, sourceAddrP);
+        else
+           rtcpM.Open(rtcpPortP);
+        cSatipPoller::GetInstance()->Register(rtcpM);
+        }
+     }
+}
+
+cString cSatipTuner::GetBaseUrl(const char *addressP, const int portP)
+{
+  debug16("%s (%s, %d) [device %d]", __PRETTY_FUNCTION__, addressP, portP, deviceIdM);
+
+  if (portP != SATIP_DEFAULT_RTSP_PORT)
+     return cString::sprintf("rtsp://%s:%d/", addressP, portP);
+
+  return cString::sprintf("rtsp://%s/", addressP);
+}
+
 int cSatipTuner::GetId(void)
 {
  debug16("%s [device %d]", __PRETTY_FUNCTION__, deviceIdM);
@@ -355,6 +437,10 @@ bool cSatipTuner::SetSource(cSatipServer *serverP, const int transponderP, const
        // Update stream address and parameter
        streamAddrM = rtspM.RtspUnescapeString(*nextServerM.GetAddress());
        streamParamM = rtspM.RtspUnescapeString(parameterP);
+        streamPortM = nextServerM.GetPort();
+        // Modify parameter if required
+        if (nextServerM.IsQuirk(cSatipServer::eSatipQuirkForcePilot) && strstr(parameterP, "msys=dvbs2") && !strstr(parameterP, "plts="))
+           streamParamM = rtspM.RtspUnescapeString(*cString::sprintf("%s&plts=on", parameterP));
        // Reconnect
        RequestState(tsSet, smExternal);
        }
@@ -393,7 +479,7 @@ bool cSatipTuner::UpdatePids(bool forceP)
  cMutexLock MutexLock(&mutexM);
  if (((forceP && pidsM.Size()) || (pidUpdateCacheM.TimedOut() && (addPidsM.Size() || delPidsM.Size()))) &&
      !isempty(*streamAddrM) && (streamIdM > 0)) {
-     cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
+     cString uri = cString::sprintf("%sstream=%d", *GetBaseUrl(*streamAddrM, streamPortM), streamIdM);
     bool useci = (SatipConfig.GetCIExtension() && currentServerM.HasCI());
     bool usedummy = currentServerM.IsQuirk(cSatipServer::eSatipQuirkPlayPids);
     if (forceP || usedummy) {
@@ -409,20 +495,30 @@ bool cSatipTuner::UpdatePids(bool forceP)
           uri = cString::sprintf("%s%sdelpids=%s", *uri, addPidsM.Size() ? "&" : "?", *delPidsM.ListPids());
        }
     if (useci) {
-        // CI extension parameters:
-        // - x_pmt : specifies the PMT of the service you want the CI to decode
-        // - x_ci  : specfies which CI slot (1..n) to use
-        //           value 0 releases the CI slot
-        //           CI slot released automatically if the stream is released,
-        //           but not when used retuning to another channel
-        int pid = deviceM->GetPmtPid();
-        if ((pid > 0) && (pid != pmtPidM)) {
-           int slot = deviceM->GetCISlot();
-           uri = cString::sprintf("%s&x_pmt=%d", *uri, pid);
-           if (slot > 0)
-              uri = cString::sprintf("%s&x_ci=%d", *uri, slot);
+        if (currentServerM.IsQuirk(cSatipServer::eSatipQuirkCiXpmt)) {
+           // CI extension parameters:
+           // - x_pmt : specifies the PMT of the service you want the CI to decode
+           // - x_ci  : specfies which CI slot (1..n) to use
+           //           value 0 releases the CI slot
+           //           CI slot released automatically if the stream is released,
+           //           but not when used retuning to another channel
+           int pid = deviceM->GetPmtPid();
+           if ((pid > 0) && (pid != pmtPidM)) {
+              int slot = deviceM->GetCISlot();
+              uri = cString::sprintf("%s&x_pmt=%d", *uri, pid);
+              if (slot > 0)
+                 uri = cString::sprintf("%s&x_ci=%d", *uri, slot);
+              }
+           pmtPidM = pid;
+           }
+        else if (currentServerM.IsQuirk(cSatipServer::eSatipQuirkCiTnr)) {
+           // CI extension parameters:
+           // - tnr : specifies a channel config entry
+           cString param = deviceM->GetTnrParameterString();
+           if (!isempty(*param) && strcmp(*tnrParamM, *param) != 0)
+              uri = cString::sprintf("%s&tnr=%s", *uri, *param);
+           tnrParamM = param;
           }
-        pmtPidM = pid;
        }
     pidUpdateCacheM.Set(ePidUpdateIntervalMs);
     if (!rtspM.Play(*uri))
@@ -443,7 +539,7 @@ bool cSatipTuner::KeepAlive(bool forceP)
     forceP = true;
     }
  if (forceP && !isempty(*streamAddrM)) {
-     cString uri = cString::sprintf("rtsp://%s/", *streamAddrM);
+     cString uri = GetBaseUrl(*streamAddrM, streamPortM);
     if (!rtspM.Options(*uri))
        return false;
     }
@@ -460,7 +556,7 @@ bool cSatipTuner::ReadReceptionStatus(bool forceP)
     forceP = true;
     }
  if (forceP && !isempty(*streamAddrM) && (streamIdM > 0)) {
-     cString uri = cString::sprintf("rtsp://%s/stream=%d", *streamAddrM, streamIdM);
+     cString uri = cString::sprintf("%sstream=%d", *GetBaseUrl(*streamAddrM, streamPortM), streamIdM);
     if (rtspM.Describe(*uri))
        return true;
     }
@@ -595,5 +691,5 @@ cString cSatipTuner::GetSignalStatus(void)
 cString cSatipTuner::GetInformation(void)
 {
  debug16("%s [device %d]", __PRETTY_FUNCTION__, deviceIdM);
-  return (currentStateM >= tsTuned) ? cString::sprintf("rtsp://%s/?%s [stream=%d]", *streamAddrM, *streamParamM, streamIdM) : "connection failed";
+  return (currentStateM >= tsTuned) ? cString::sprintf("%s?%s (%s) [stream=%d]", *GetBaseUrl(*streamAddrM, streamPortM), *streamParamM, *rtspM.GetActiveMode(), streamIdM) : "connection failed";
 }
--- a/tuner.h
+++ b/tuner.h
@@ -69,6 +69,8 @@ public:
  void Set(cSatipServer *serverP, const int transponderP) { serverM = serverP; transponderM = transponderP; }
  void Reset(void) { serverM = NULL; transponderM = 0; }
  cString GetAddress(void) { return serverM ? cSatipDiscover::GetInstance()->GetServerAddress(serverM) : ""; }
+  cString GetSrcAddress(void) { return serverM ? cSatipDiscover::GetInstance()->GetSourceAddress(serverM) : ""; }
+  int GetPort(void) { return serverM ? cSatipDiscover::GetInstance()->GetServerPort(serverM) : SATIP_DEFAULT_RTSP_PORT; }
  cString GetInfo(void) { return cString::sprintf("server=%s deviceid=%d transponder=%d", serverM ? "assigned" : "null", deviceIdM, transponderM); }
 };

@@ -83,6 +85,8 @@ private:
    eStatusUpdateTimeoutMs  = 1000,  // in milliseconds
    ePidUpdateIntervalMs    = 250,   // in milliseconds
    eConnectTimeoutMs       = 5000,  // in milliseconds
+    eIdleCheckTimeoutMs     = 15000, // in milliseconds
+    eTuningTimeoutMs        = 20000, // in milliseconds
    eMinKeepAliveIntervalMs = 30000  // in milliseconds
  };
  enum eTunerState { tsIdle, tsRelease, tsSet, tsTuned, tsLocked };
@@ -96,6 +100,8 @@ private:
  cSatipRtcp rtcpM;
  cString streamAddrM;
  cString streamParamM;
+  cString tnrParamM;
+  int streamPortM;
  cSatipTunerServer currentServerM;
  cSatipTunerServer nextServerM;
  cMutex mutexM;
@@ -128,6 +134,7 @@ private:
  bool RequestState(eTunerState stateP, eStateMode modeP);
  const char *StateModeString(eStateMode modeP);
  const char *TunerStateString(eTunerState stateP);
+  cString GetBaseUrl(const char *addressP, const int portP);

 protected:
  virtual void Action(void);
@@ -151,8 +158,11 @@ public:
 public:
  virtual void ProcessVideoData(u_char *bufferP, int lengthP);
  virtual void ProcessApplicationData(u_char *bufferP, int lengthP);
+  virtual void ProcessRtpData(u_char *bufferP, int lengthP);
+  virtual void ProcessRtcpData(u_char *bufferP, int lengthP);
  virtual void SetStreamId(int streamIdP);
  virtual void SetSessionTimeout(const char *sessionP, int timeoutP);
+  virtual void SetupTransport(int rtpPortP, int rtcpPortP, const char *streamAddrP, const char *sourceAddrP);
  virtual int GetId(void);
 };

--- a/tunerif.h
+++ b/tunerif.h
@@ -14,12 +14,15 @@ public:
  virtual ~cSatipTunerIf() {}
  virtual void ProcessVideoData(u_char *bufferP, int lengthP) = 0;
  virtual void ProcessApplicationData(u_char *bufferP, int lengthP) = 0;
+  virtual void ProcessRtpData(u_char *bufferP, int lengthP) = 0;
+  virtual void ProcessRtcpData(u_char *bufferP, int lengthP) = 0;
  virtual void SetStreamId(int streamIdP) = 0;
  virtual void SetSessionTimeout(const char *sessionP, int timeoutP) = 0;
+  virtual void SetupTransport(int rtpPortP, int rtcpPortP, const char *streamAddrP, const char *sourceAddrP) = 0;
  virtual int GetId(void) = 0;

 private:
-  cSatipTunerIf(const cSatipTunerIf&);
+  explicit cSatipTunerIf(const cSatipTunerIf&);
  cSatipTunerIf& operator=(const cSatipTunerIf&);
 };
Author	SHA1	Message	Date
Rolf Ahrenberg	c07d921193	Silence "misleading-indentation" warning.	2018-03-14 23:23:27 +02:00
Rolf Ahrenberg	d333bcebb7	Remove speed limit.	2018-02-13 17:24:09 +02:00
Rolf Ahrenberg	0ce8ae7206	Avoid closing RTP/RTCP ports.	2018-02-06 22:55:52 +02:00
Rolf Ahrenberg	2c6c6ea5fd	Fixed transport media change for RTCP.	2018-02-06 22:36:59 +02:00
Rolf Ahrenberg	28cc3cae63	Strip off the constructor delegation after all to broaden compiler compability.	2017-11-19 15:25:31 +02:00
Rolf Ahrenberg	0abccf2370	Merge pull request #46 from srehm/vdr-2.2.x Configurable RTP receive buffer size	2017-11-19 14:59:50 +02:00
Stefan Rehm	f303298923	Added command line parameter to make the RTP receive bufferr size configurable.	2017-11-19 13:49:59 +01:00
Rolf Ahrenberg	f3fe1e9a13	Serialize channel switching to prevent device allocation failures.	2017-11-18 12:25:33 +02:00
Alexander Pipelka	364b4fbec7	Ignore handlers without any data.	2017-10-04 21:55:07 +03:00
Rolf Ahrenberg	b004793ef3	Cleanup section filter code.	2017-10-01 22:39:23 +03:00
Alexander Pipelka	ae403212f7	Moved send loop one level down.	2017-10-01 22:39:12 +03:00
Alexander Pipelka	09941322b1	Changed include header.	2017-10-01 22:39:03 +03:00
Alexander Pipelka	3713d1a1fa	Use error() to display error messages.	2017-10-01 22:38:54 +03:00
Alexander Pipelka	2355dad37b	Defined section filter send timeout.	2017-10-01 22:38:46 +03:00
Alexander Pipelka	de6c0e1f89	Minor coding-style fix.	2017-10-01 22:38:38 +03:00
Alexander Pipelka	bbd7f2da51	Removed dead sleep code (comment) in cSatipSectionFilterHandler::Action().	2017-10-01 22:38:21 +03:00
Alexander Pipelka	e11396e84d	Added transfer timeout for sectionfilter data.	2017-10-01 22:38:14 +03:00
Alexander Pipelka	dfb050c297	Fixed memory leak in cSatipSectionFilter.	2017-10-01 18:31:39 +03:00
Rolf Ahrenberg	ee88aadf60	Updated version number.	2017-08-15 09:17:11 +03:00
Sascha Kuehndel (InuSasha)	e405a31f48	fix gcc7 compiling	2017-08-15 09:11:02 +03:00
Rolf Ahrenberg	1a254029d5	Fix info messages.	2017-08-15 09:10:49 +03:00
Rolf Ahrenberg	87f9555290	Refactor the server detection script.	2017-08-15 09:10:28 +03:00
Rolf Ahrenberg	b21398938b	Add a server detection script.	2017-08-15 09:10:16 +03:00
Rolf Ahrenberg	fb6282b44f	Add support for interface binding via a defined source address.	2017-08-15 09:09:48 +03:00
Rolf Ahrenberg	01533ef6be	Update quirks for FRITZ!WLAN Repeater DVB-C and FRITZ!Box 6490 Cable devices.	2017-08-15 09:09:16 +03:00
Tomasz Maciej Nowak	1ca7cae7e4	Add polish language	2017-08-15 09:04:52 +03:00
kavanu	974c26bdd6	added name of "KATHREIN SatIP Server"	2017-05-20 14:17:11 +03:00
Rolf Ahrenberg	ed99cfba79	Remove non-compatible RTP-over-TCP devices.	2017-02-25 14:05:32 +02:00
Frank Neumann	5b01fa34aa	Update Catalan and Espanol translations.	2017-02-11 19:33:13 +02:00
Rolf Ahrenberg	0bad1c1702	Add musl-libc compatibility.	2017-01-05 17:28:28 +02:00
Rolf Ahrenberg	6573c38fb6	Updated HISTORY.	2016-12-18 17:28:41 +02:00
Rolf Ahrenberg	581ac4966d	Prefer section pids.	2016-12-16 08:18:41 +02:00
Rolf Ahrenberg	99e366b261	Add a preliminary RTP-over-TCP support.	2016-12-15 23:48:22 +02:00
Frank Neumann	3b89dd4b01	Update German translations.	2016-12-15 08:11:34 +02:00
Rolf Ahrenberg	ee6ac0d48a	Add a preliminary multicast support.	2016-12-14 00:39:22 +02:00
Rolf Ahrenberg	e6c9776ec9	Add a new ForcePilot quirk.	2016-11-10 16:54:12 +02:00
Rolf Ahrenberg	7aef2a3dff	Update README.	2016-11-10 16:52:08 +02:00
Rolf Ahrenberg	61b56db909	Add command-line support for setting server quirks.	2016-10-09 18:55:12 +03:00
Rolf Ahrenberg	4c45787541	Add preliminary support for DVBViewer CI.	2016-09-11 13:13:24 +03:00
Rolf Ahrenberg	f65dca2910	Handle Out-of-Range responses as a normal operation.	2016-09-11 13:12:59 +03:00
Rolf Ahrenberg	db0c18ba33	Check source validity also in server assign (Thanks to Patrick Boettcher).	2016-07-31 12:02:31 +03:00
Rolf Ahrenberg	0f9e0014df	Add support for source filtering.	2016-07-30 13:43:57 +03:00
Rolf Ahrenberg	6bb7fb511b	Fix command-line examples to match defined quirks.	2016-07-23 17:38:28 +03:00
Rolf Ahrenberg	7815821824	Fix active device check.	2016-06-23 15:38:36 +03:00
Rolf Ahrenberg	bc481bcc4d	Add support for activating/deactivating server on-the-fly.	2016-06-22 22:49:46 +03:00
Rolf Ahrenberg	7289da9f41	Add support for RTP-over-TCP.	2016-06-21 23:03:39 +03:00
Rolf Ahrenberg	d5e0106d8e	Change EINTR handling in poller.	2016-06-05 14:20:50 +03:00
Rolf Ahrenberg	fe532e2248	Use 2MB ringbuffer per device.	2016-05-12 23:48:01 +03:00
Rolf Ahrenberg	b5483b9d77	Set SO_REUSEPORT only if it's defined.	2016-05-07 21:45:28 +03:00
Rolf Ahrenberg	fd23b0483a	Re-enable to reuse address for msearch protocol.	2016-04-11 23:06:03 +03:00
Rolf Ahrenberg	18c9b79533	Reset device name when the device is idling.	2016-03-19 20:37:21 +02:00
Rolf Ahrenberg	e4f560c66e	Fix statistics output a bit more.	2016-02-28 18:24:29 +02:00
Rolf Ahrenberg	57ea119d03	Fix statistics output.	2016-02-28 15:36:12 +02:00
Rolf Ahrenberg	ae8298d19a	Added support for X-SATIP-RTSP-Port header.	2016-02-27 17:32:27 +02:00
Tobias Grimm	b755dbf318	C++11 requires a mandatory space when concatenating string literals	2016-01-30 21:52:12 +02:00
Rolf Ahrenberg	8f12ce6f55	Add a missing device name update.	2016-01-30 21:51:49 +02:00
chriszero	9d5f7cc703	Make it possible to specify the rtp and rtcp ports this makes it possible to use the satip through a NAT (e.g. a docker bridged network)	2016-01-08 20:26:02 +02:00
Rolf Ahrenberg	c1a881ba94	Reorder also terrestrial and cable query parameters as introduced in the satip specification 1.2.2, although the ordering shouldn't matter according to it.	2016-01-08 20:25:44 +02:00
Tobias Grimm	165fd5b14a	Reorderd the transponder URL parameter in a way the Panasonic CXW804 expects them (src/freq/pol/ro/msys/mtype/plts/sr/fec) This only applies to DVB-S. DVB-C and DVB-T might need further tweaking. It's actually a bug of the Panasonic TV to expect the transponder parameters in a specific order in the query string, but for now this seems to be the most pragmatic workaround.	2016-01-08 20:25:04 +02:00
Rolf Ahrenberg	37a0572a64	Updated HISTORY.	2015-09-18 18:49:44 +03:00
Rolf Ahrenberg	613c0aed7c	Added a force lock quirk for Schwaiger MS41IP.	2015-09-18 18:31:53 +03:00
Rolf Ahrenberg	c3ad29eb27	Updated for vdr-2.3.1 (Thanks to Klaus Schmidinger).	2015-08-20 19:12:21 +03:00
Rolf Ahrenberg	e90b8651e6	Silenced some cppcheck warnings.	2015-08-16 01:38:03 +03:00
Rolf Ahrenberg	0f370aa36a	Added a tuning timeout for better recovery.	2015-08-16 01:10:52 +03:00
Rolf Ahrenberg	49e2dd1fc1	Reset the RTSP connection after any failed connect.	2015-06-04 18:51:09 +03:00
Rolf Ahrenberg	ba0b808ec4	Enabled the X_PMT extension for minisatip servers.	2015-05-26 21:18:05 +03:00
Rolf Ahrenberg	4e2535a7e2	Added a double check for the idle release.	2015-05-23 15:28:37 +03:00
Rolf Ahrenberg	6384b8694e	Added a timeout for releasing idling devices.	2015-05-22 22:43:08 +03:00
Rolf Ahrenberg	6c4c8a10b7	Set the default device count to two.	2015-04-26 12:49:40 +03:00
Rolf Ahrenberg	8b43cdc634	Added initial support for detaching and attaching SAT>IP servers.	2015-04-12 21:25:41 +03:00
Rolf Ahrenberg	fe010ab72c	Added a more flexible OPER command in the SVDRP interface.	2015-04-09 21:36:13 +03:00