dvbdevice.h

Go to the documentation of this file.

/*
 * dvbdevice.h: The DVB device tuner interface
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: dvbdevice.h 5.2 2025/03/02 11:03:35 kls Exp $
 */
 
#ifndef __DVBDEVICE_H
#define __DVBDEVICE_H
 
#include <linux/dvb/frontend.h>
#include <linux/dvb/version.h>
#include <atomic>
#include "device.h"
 
#define DVBAPIVERSION (DVB_API_VERSION << 8 | DVB_API_VERSION_MINOR)
 
#if DVBAPIVERSION < 0x0500
#error VDR requires Linux DVB driver API version 5.0 or higher!
#endif
 
// --- Definitions for older DVB API versions --------------------------------
 
#if DVBAPIVERSION < 0x0501
enum {
  FE_CAN_2G_MODULATION = 0x10000000,
  };
enum {
  TRANSMISSION_MODE_4K = TRANSMISSION_MODE_AUTO + 1,
  };
#endif
 
#if DVBAPIVERSION < 0x0502
enum {
  FE_CAN_TURBO_FEC = 0x8000000,
  };
#endif
 
#if DVBAPIVERSION < 0x0503
enum {
  TRANSMISSION_MODE_1K = TRANSMISSION_MODE_4K + 1,
  TRANSMISSION_MODE_16K,
  TRANSMISSION_MODE_32K,
  };
enum {
  GUARD_INTERVAL_1_128 = GUARD_INTERVAL_AUTO + 1,
  GUARD_INTERVAL_19_128,
  GUARD_INTERVAL_19_256,
  };
enum {
  SYS_DVBT2 = SYS_DAB + 1,
  };
#endif
 
#if DVBAPIVERSION < 0x0505
#define DTV_ENUM_DELSYS  44
#endif
 
#if DVBAPIVERSION < 0x0508
enum {
  FE_CAN_MULTISTREAM = 0x4000000,
  };
#define DTV_STREAM_ID            42
#define DTV_DVBT2_PLP_ID_LEGACY  43
#endif
 
// --- End of definitions for older DVB API versions -------------------------
 
#define DEV_VIDEO         "/dev/video"
#define DEV_DVB_BASE      "/dev/dvb"
#define DEV_DVB_ADAPTER   "adapter"
#define DEV_DVB_OSD       "osd"
#define DEV_DVB_FRONTEND  "frontend"
#define DEV_DVB_DVR       "dvr"
#define DEV_DVB_DEMUX     "demux"
#define DEV_DVB_VIDEO     "video"
#define DEV_DVB_AUDIO     "audio"
#define DEV_DVB_CA        "ca"
 
struct tDvbParameterMap {
  int userValue;
  int driverValue;
  const char *userString;
  };
 
const char *MapToUserString(int Value, const tDvbParameterMap *Map);
int MapToUser(int Value, const tDvbParameterMap *Map, const char **String = NULL);
int MapToDriver(int Value, const tDvbParameterMap *Map);
int UserIndex(int Value, const tDvbParameterMap *Map);
int DriverIndex(int Value, const tDvbParameterMap *Map);
 
extern const tDvbParameterMap PilotValues[];
extern const tDvbParameterMap InversionValues[];
extern const tDvbParameterMap BandwidthValues[];
extern const tDvbParameterMap CoderateValues[];
extern const tDvbParameterMap ModulationValues[];
extern const tDvbParameterMap SystemValuesSat[];
extern const tDvbParameterMap SystemValuesTerr[];
extern const tDvbParameterMap TransmissionValues[];
extern const tDvbParameterMap GuardValues[];
extern const tDvbParameterMap HierarchyValues[];
extern const tDvbParameterMap RollOffValues[];
 
class cDvbTransponderParameters {
friend class cDvbSourceParam;
private:
  char polarization;
  int inversion;
  int bandwidth;
  int coderateH;
  int coderateL;
  int modulation;
  int system;
  int transmission;
  int guard;
  int hierarchy;
  int rollOff;
  int streamId;
  int t2systemId;
  int sisoMiso;
  int pilot;
  int PrintParameter(char *p, char Name, int Value) const;
  const char *ParseParameter(const char *s, int &Value, const tDvbParameterMap *Map = NULL);
public:
  cDvbTransponderParameters(const char *Parameters = NULL);
  char Polarization(void) const { return polarization; }
  int Inversion(void) const { return inversion; }
  int Bandwidth(void) const { return bandwidth; }
  int CoderateH(void) const { return coderateH; }
  int CoderateL(void) const { return coderateL; }
  int Modulation(void) const { return modulation; }
  int System(void) const { return system; }
  int Transmission(void) const { return transmission; }
  int Guard(void) const { return guard; }
  int Hierarchy(void) const { return hierarchy; }
  int RollOff(void) const { return rollOff; }
  int StreamId(void) const { return streamId; }
  int T2SystemId(void) const { return t2systemId; }
  int SisoMiso(void) const { return sisoMiso; }
  int Pilot(void) const { return pilot; }
  void SetPolarization(char Polarization) { polarization = Polarization; }
  void SetInversion(int Inversion) { inversion = Inversion; }
  void SetBandwidth(int Bandwidth) { bandwidth = Bandwidth; }
  void SetCoderateH(int CoderateH) { coderateH = CoderateH; }
  void SetCoderateL(int CoderateL) { coderateL = CoderateL; }
  void SetModulation(int Modulation) { modulation = Modulation; }
  void SetSystem(int System) { system = System; }
  void SetTransmission(int Transmission) { transmission = Transmission; }
  void SetGuard(int Guard) { guard = Guard; }
  void SetHierarchy(int Hierarchy) { hierarchy = Hierarchy; }
  void SetRollOff(int RollOff) { rollOff = RollOff; }
  void SetStreamId(int StreamId) { streamId = StreamId; }
  void SetT2SystemId(int T2SystemId) { t2systemId = T2SystemId; }
  void SetSisoMiso(int SisoMiso) { sisoMiso = SisoMiso; }
  void SetPilot(int Pilot) { pilot = Pilot; }
  cString ToString(char Type) const;
  bool Parse(const char *s);
  };
 
class cDvbTuner;
 
cString DvbName(const char *Name, int Adapter, int Frontend);
int DvbOpen(const char *Name, int Adapter, int Frontend, int Mode, bool ReportError = false);

 
class cDvbDevice : public cDevice {
private:
  static bool Exists(int Adapter, int Frontend);
  static bool Probe(int Adapter, int Frontend);
public:
  static bool useDvbDevices;
  static bool Initialize(void);
protected:
  int adapter, frontend;
  virtual bool IsBonded(void) const override { return bondedDevice; }
private:
  int fd_dvr, fd_ca;
  bool checkTsBuffer;
  static cMutex bondMutex;
  cDvbDevice *bondedDevice;
  mutable std::atomic<bool> needsDetachBondedReceivers; // set by ProvidesChannel() on whichever thread asks
public:
  cDvbDevice(int Adapter, int Frontend);
  virtual ~cDvbDevice() override;
  int Adapter(void) const { return adapter; }
  int Frontend(void) const;
  virtual cString DeviceType(void) const override;
  virtual cString DeviceName(void) const override;
  static bool BondDevices(const char *Bondings);
  static void UnBondDevices(void);
  bool Bond(cDvbDevice *Device);
  void UnBond(void);
  bool BondingOk(const cChannel *Channel, bool ConsiderOccupied = false) const;
 
// Common Interface facilities:
 
private:
  cCiAdapter *ciAdapter;
 
// Channel facilities
 
private:
  cDvbTuner *dvbTuner;
public:
  virtual bool ProvidesDeliverySystem(int DeliverySystem) const;
  virtual bool ProvidesSource(int Source) const override;
  virtual bool ProvidesTransponder(const cChannel *Channel) const override;
  virtual bool ProvidesChannel(const cChannel *Channel, int Priority = IDLEPRIORITY, bool *NeedsDetachReceivers = NULL) const override;
  virtual bool ProvidesEIT(void) const override;
  virtual int NumProvidedSystems(void) const override;
  virtual const cPositioner *Positioner(void) const override;
  virtual bool SignalStats(int &Valid, double *Strength = NULL, double *Cnr = NULL, double *BerPre = NULL, double *BerPost = NULL, double *Per = NULL, int *Status = NULL) const override;
  virtual int SignalStrength(void) const override;
  virtual int SignalQuality(void) const override;
  virtual const cChannel *GetCurrentlyTunedTransponder(void) const override;
  virtual bool IsTunedToTransponder(const cChannel *Channel) const override;
  virtual bool MaySwitchTransponder(const cChannel *Channel) const override;
  virtual void SetPowerSaveMode(bool On) override;
protected:
  virtual bool SetChannelDevice(const cChannel *Channel, bool LiveView) override;
public:
  virtual bool HasLock(int TimeoutMs = 0) const override;
 
// PID handle facilities
 
protected:
  virtual bool SetPid(cPidHandle *Handle, int Type, bool On) override;
 
// Section filter facilities
 
protected:
  virtual int OpenFilter(u_short Pid, u_char Tid, u_char Mask) override;
  virtual void CloseFilter(int Handle) override;
 
// Common Interface facilities:
 
public:
  virtual bool HasCi(void) override;
 
// Audio facilities
 
protected:
  static int setTransferModeForDolbyDigital;
public:
  static void SetTransferModeForDolbyDigital(int Mode); // needs to be here for backwards compatibility
 
// Receiver facilities
 
private:
  cTSBuffer *tsBuffer;
protected:
  virtual bool OpenDvr(void) override;
  virtual void CloseDvr(void) override;
  virtual bool GetTSPacket(uchar *&Data) override;
  virtual void DetachAllReceivers(void) override;
  };
 
// A plugin that implements a DVB device derived from cDvbDevice needs to create
// a cDvbDeviceProbe derived object on the heap in order to have its Probe()
// function called, where it can actually create the appropriate device.
// The cDvbDeviceProbe object must be created in the plugin's constructor,
// and deleted in its destructor.
 
class cDvbDeviceProbe : public cListObject {
public:
  cDvbDeviceProbe(void);
  virtual ~cDvbDeviceProbe() override;
  static uint32_t GetSubsystemId(int Adapter, int Frontend);
  virtual bool Probe(int Adapter, int Frontend) = 0;
  };
 
extern cList<cDvbDeviceProbe> DvbDeviceProbes;
 
#endif //__DVBDEVICE_H