device.h

Go to the documentation of this file.

/*
 * device.h: The basic device interface
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: device.h 5.12 2026/09/24 20:28:19 kls Exp $
 */
 
#ifndef __DEVICE_H
#define __DEVICE_H
 
#include "channels.h"
#include "ci.h"
#include "dvbsubtitle.h"
#include "eit.h"
#include "filter.h"
#include "nit.h"
#include "pat.h"
#include "positioner.h"
#include "remux.h"
#include "ringbuffer.h"
#include "sdt.h"
#include "sections.h"
#include "spu.h"
#include "thread.h"
#include "tools.h"
 
#define MAXDEVICES         32 // the maximum number of devices in the system
#define MAXPIDHANDLES      64 // the maximum number of different PIDs per device
#define MAXRECEIVERS       16 // the maximum number of receivers per device
#define MAXVOLUME         255
#define VOLUMEDELTA       (MAXVOLUME / Setup.VolumeSteps) // used to increase/decrease the volume
#define MAXOCCUPIEDTIMEOUT 99 // max. time (in seconds) a device may be occupied
 
enum eSetChannelResult { scrOk, scrNotAvailable, scrNoTransfer, scrFailed };
 
// Note that VDR itself always uses pmAudioVideo when replaying a recording!
enum ePlayMode { pmNone,           // audio/video from decoder
                 pmAudioVideo,     // audio/video from player
                 pmAudioOnly,      // audio only from player, video from decoder
                 pmAudioOnlyBlack, // audio only from player, no video (black screen)
                 pmVideoOnly,      // video only from player, audio from decoder
                 pmExtern_THIS_SHOULD_BE_AVOIDED
                 // external player (e.g. MPlayer), release the device
                 // WARNING: USE THIS MODE ONLY AS A LAST RESORT, IF YOU
                 // ABSOLUTELY, POSITIVELY CAN'T IMPLEMENT YOUR PLAYER
                 // THE WAY IT IS SUPPOSED TO WORK. FORCING THE DEVICE
                 // TO RELEASE ITS FILES HANDLES (OR WHATEVER RESOURCES
                 // IT MAY USE) TO ALLOW AN EXTERNAL PLAYER TO ACCESS
                 // THEM MEANS THAT SUCH A PLAYER WILL NEED TO HAVE
                 // DETAILED KNOWLEDGE ABOUT THE INTERNALS OF THE DEVICE
                 // IN USE. AS A CONSEQUENCE, YOUR PLAYER MAY NOT WORK
                 // IF A PARTICULAR VDR INSTALLATION USES A DEVICE NOT
                 // KNOWN TO YOUR PLAYER.
               };
 
enum eVideoDisplayFormat { vdfPanAndScan,
                           vdfLetterBox,
                           vdfCenterCutOut
                         };
 
enum eTrackType { ttNone,
                  ttAudio,
                  ttAudioFirst = ttAudio,
                  ttAudioLast  = ttAudioFirst + 31, // MAXAPIDS - 1
                  ttDolby,
                  ttDolbyFirst = ttDolby,
                  ttDolbyLast  = ttDolbyFirst + 15, // MAXDPIDS - 1
                  ttSubtitle,
                  ttSubtitleFirst = ttSubtitle,
                  ttSubtitleLast  = ttSubtitleFirst + 31, // MAXSPIDS - 1
                  ttMaxTrackTypes
                };
 
#define IS_AUDIO_TRACK(t) (ttAudioFirst <= (t) && (t) <= ttAudioLast)
#define IS_DOLBY_TRACK(t) (ttDolbyFirst <= (t) && (t) <= ttDolbyLast)
#define IS_SUBTITLE_TRACK(t) (ttSubtitleFirst <= (t) && (t) <= ttSubtitleLast)
 
struct tTrackId {
  uint16_t id;                  // The PES packet id or the PID.
  char language[MAXLANGCODE2];  // something like either "eng" or "deu+eng"
  char description[32];         // something like "Dolby Digital 5.1"
  };
 
class cPlayer;
class cReceiver;
class cLiveSubtitle;
 
class cDeviceHook : public cListObject {
public:
  cDeviceHook(void);
  virtual bool DeviceProvidesTransponder(const cDevice *Device, const cChannel *Channel) const;
  virtual bool DeviceProvidesEIT(const cDevice *Device) const;
  };

 
#define DTV_STAT_VALID_NONE      0x0000
#define DTV_STAT_VALID_STRENGTH  0x0001
#define DTV_STAT_VALID_CNR       0x0002
#define DTV_STAT_VALID_BERPRE    0x0004
#define DTV_STAT_VALID_BERPOST   0x0008
#define DTV_STAT_VALID_PER       0x0010
#define DTV_STAT_VALID_STATUS    0x0020
 
#define DTV_STAT_HAS_NONE        0x0000
#define DTV_STAT_HAS_SIGNAL      0x0001
#define DTV_STAT_HAS_CARRIER     0x0002
#define DTV_STAT_HAS_VITERBI     0x0004
#define DTV_STAT_HAS_SYNC        0x0008
#define DTV_STAT_HAS_LOCK        0x0010
 
class cDevice : public cThread {
  friend class cLiveSubtitle;
  friend class cDeviceHook;
  friend class cReceiver;
private:
  static int numDevices;
  static int useDevice;
  static cDevice *device[MAXDEVICES];
  static cDevice *primaryDevice;
public:
  static int NumDevices(void) { return numDevices; }
  static bool WaitForAllDevicesReady(int Timeout = 0);
  static void SetUseDevice(int n);
  static bool UseDevice(int n) { return useDevice == 0 || (useDevice & (1 << n)) != 0; }
  static bool SetPrimaryDevice(int n);
  static cDevice *PrimaryDevice(void) { return primaryDevice; }
  static cDevice *ActualDevice(void);
  static cDevice *GetDevice(int Index);
  static cDevice *GetDevice(const cChannel *Channel, int Priority, bool LiveView, bool Query = false);
  static cDevice *GetDeviceForTransponder(const cChannel *Channel, int Priority);
  static void Shutdown(void);
private:
  static int nextCardIndex;
  int cardIndex;
protected:
  cDevice(void);
  virtual ~cDevice() override;
  virtual bool Ready(void);
  static int NextCardIndex(int n = 0);
  virtual void MakePrimaryDevice(bool On);
  virtual bool IsBonded(void) const { return false; }
public:
  bool IsPrimaryDevice(bool CheckDecoder = true) const { return this == primaryDevice && (!CheckDecoder || HasDecoder()); }
  int CardIndex(void) const { return cardIndex; }
  int DeviceNumber(void) const;
  virtual cString DeviceType(void) const;
  virtual cString DeviceName(void) const;
  virtual bool HasDecoder(void) const;
  virtual bool AvoidRecording(void) const { return false; }
 
// Device hooks
 
private:
  static cList<cDeviceHook> deviceHooks;
protected:
  bool DeviceHooksProvidesTransponder(const cChannel *Channel) const;
  bool DeviceHooksProvidesEIT(void) const;
 
// SPU facilities
 
private:
  cLiveSubtitle *liveSubtitle;
  cDvbSubtitleConverter *dvbSubtitleConverter;
public:
  virtual cSpuDecoder *GetSpuDecoder(void);
 
// Channel facilities
 
private:
  mutable cMutex mutexChannel;
  time_t occupiedFrom;
  time_t occupiedTimeout;
  int occupiedPriority;
protected:
  static std::atomic<int> currentChannel; // set by whichever thread switches the channel, read by any
public:
  virtual bool ProvidesSource(int Source) const;
  virtual bool ProvidesTransponder(const cChannel *Channel) const;
  virtual bool ProvidesTransponderExclusively(const cChannel *Channel) const;
  virtual bool ProvidesChannel(const cChannel *Channel, int Priority = IDLEPRIORITY, bool *NeedsDetachReceivers = NULL) const;
  virtual bool ProvidesEIT(void) const;
  virtual int NumProvidedSystems(void) const;
  virtual const cPositioner *Positioner(void) const;
  virtual bool SignalStats(int &Valid, double *Strength = NULL, double *Cnr = NULL, double *BerPre = NULL, double *BerPost = NULL, double *Per = NULL, int *Status = NULL) const;
  virtual int SignalStrength(void) const;
  virtual int SignalQuality(void) const;
  virtual const cChannel *GetCurrentlyTunedTransponder(void) const;
  virtual bool IsTunedToTransponder(const cChannel *Channel) const;
  virtual bool MaySwitchTransponder(const cChannel *Channel) const;
  virtual void SetPowerSaveMode(bool On);
  void SetPowerSaveIfUnused(void);
  bool SwitchChannel(const cChannel *Channel, bool LiveView);
  static bool SwitchChannel(int Direction);
private:
  eSetChannelResult SetChannel(const cChannel *Channel, bool LiveView);
protected:
  virtual bool SetChannelDevice(const cChannel *Channel, bool LiveView);
public:
  static int CurrentChannel(void) { return primaryDevice ? currentChannel.load() : 0; }
  static void SetCurrentChannel(int ChannelNumber) { currentChannel = ChannelNumber; }
  void ForceTransferMode(void);
  int Occupied(int Priority = MINPRIORITY) const;
  void SetOccupied(int Seconds, int Priority = MINPRIORITY, time_t From = 0);
  virtual bool HasLock(int TimeoutMs = 0) const;
  virtual bool HasProgramme(void) const;
 
// PID handle facilities
 
private:
  mutable cMutex mutexPids;
  virtual void Action(void) override;
protected:
  enum ePidType { ptAudio, ptVideo, ptPcr, ptTeletext, ptDolby, ptOther };
  class cPidHandle {
  public:
    int pid;
    int streamType;
    int handle;
    int used;
    cPidHandle(void) { pid = streamType = used = 0; handle = -1; }
    };
  cPidHandle pidHandles[MAXPIDHANDLES];
  bool HasPid(int Pid) const;
  bool AddPid(int Pid, ePidType PidType = ptOther, int StreamType = 0);
  void DelPid(int Pid, ePidType PidType = ptOther);
  virtual bool SetPid(cPidHandle *Handle, int Type, bool On);
public:
  void DelLivePids(void);
 
// Section filter facilities
 
private:
  cSectionHandler *sectionHandler;
  cEitFilter *eitFilter;
  cPatFilter *patFilter;
  cSdtFilter *sdtFilter;
  cNitFilter *nitFilter;
protected:
  void StartSectionHandler(void);
  void StopSectionHandler(void);
public:
  virtual int OpenFilter(u_short Pid, u_char Tid, u_char Mask);
  virtual int ReadFilter(int Handle, void *Buffer, size_t Length);
  virtual void CloseFilter(int Handle);
  void AttachFilter(cFilter *Filter);
  void Detach(cFilter *Filter);
  const cSdtFilter *SdtFilter(void) const { return sdtFilter; }
  cSectionHandler *SectionHandler(void) const { return sectionHandler; }
 
// Common Interface facilities:
 
private:
  std::atomic<cCamSlot *> camSlot; // set by cCamSlot::Assign() in any thread, read without a lock
  void ReleaseCamSlot(void);
public:
  virtual bool HasCi(void);
  virtual bool HasInternalCam(void) { return false; }
  void SetCamSlot(cCamSlot *CamSlot);
  cCamSlot *CamSlot(void) const { return camSlot; }
 
// Image Grab facilities
 
public:
  virtual uchar *GrabImage(int &Size, bool Jpeg = true, int Quality = -1, int SizeX = -1, int SizeY = -1);
  bool GrabImageFile(const char *FileName, bool Jpeg = true, int Quality = -1, int SizeX = -1, int SizeY = -1);
 
// Video format facilities
 
public:
  virtual void SetVideoDisplayFormat(eVideoDisplayFormat VideoDisplayFormat);
  virtual void SetVideoFormat(bool VideoFormat16_9);
  virtual void GetVideoSize(int &Width, int &Height, double &VideoAspect);
  virtual void GetOsdSize(int &Width, int &Height, double &PixelAspect);
 
// Track facilities
 
private:
  tTrackId availableTracks[ttMaxTrackTypes];
  // read without a lock by PlayTs() and the getters, while other threads change them:
  std::atomic<eTrackType> currentAudioTrack;
  std::atomic<eTrackType> currentSubtitleTrack;
  cMutex mutexCurrentAudioTrack;
  cMutex mutexCurrentSubtitleTrack;
  int currentAudioTrackMissingCount;
  bool autoSelectPreferredSubtitleLanguage;
  bool keepTracks;
  int pre_1_3_19_PrivateStream;
protected:
  virtual void SetAudioTrackDevice(eTrackType Type);
  virtual void SetSubtitleTrackDevice(eTrackType Type);
public:
  void ClrAvailableTracks(bool DescriptionsOnly = false, bool IdsOnly = false);
  bool SetAvailableTrack(eTrackType Type, int Index, uint16_t Id, const char *Language = NULL, const char *Description = NULL);
  const tTrackId *GetTrack(eTrackType Type);
  bool GetTrackId(eTrackType Type, tTrackId &TrackId);
  int NumTracks(eTrackType FirstTrack, eTrackType LastTrack) const;
  int NumAudioTracks(void) const;
  int NumSubtitleTracks(void) const;
  eTrackType GetCurrentAudioTrack(void) const { return currentAudioTrack; }
  bool SetCurrentAudioTrack(eTrackType Type);
  eTrackType GetCurrentSubtitleTrack(void) const { return currentSubtitleTrack; }
  bool SetCurrentSubtitleTrack(eTrackType Type, bool Manual = false);
  void SetTempSubtitles(void);
  void EnsureAudioTrack(bool Force = false);
  void EnsureSubtitleTrack(void);
  void SetKeepTracks(bool KeepTracks) { keepTracks = KeepTracks; }
 
// Audio facilities
 
private:
  bool mute;
  int volume;
protected:
  virtual int GetAudioChannelDevice(void);
  virtual void SetAudioChannelDevice(int AudioChannel);
  virtual void SetVolumeDevice(int Volume);
  virtual void SetDigitalAudioDevice(bool On);
public:
  bool IsMute(void) const { return mute; }
  bool ToggleMute(void);
  int GetAudioChannel(void);
  void SetAudioChannel(int AudioChannel);
  void SetVolume(int Volume, bool Absolute = false);
  static int CurrentVolume(void) { return primaryDevice ? primaryDevice->volume : 0; }//XXX???
 
// Player facilities
 
private:
  std::atomic<cPlayer *> player; // cleared by Detach() in any thread, read without a lock
  cPatPmtParser patPmtParser;
  cTsToPes tsToPesVideo;
  cTsToPes tsToPesAudio;
  cTsToPes tsToPesSubtitle;
  bool isPlayingVideo;
protected:
  const cPatPmtParser *PatPmtParser(void) const { return &patPmtParser; }
  virtual bool CanReplay(void) const;
  virtual bool SetPlayMode(ePlayMode PlayMode);
  virtual int PlayVideo(const uchar *Data, int Length);
  virtual int PlayAudio(const uchar *Data, int Length, uchar Id);
  virtual int PlaySubtitle(const uchar *Data, int Length);
  virtual int PlayPesPacket(const uchar *Data, int Length, bool VideoOnly = false);
  virtual int PlayTsVideo(const uchar *Data, int Length);
  virtual int PlayTsAudio(const uchar *Data, int Length);
  virtual int PlayTsSubtitle(const uchar *Data, int Length);
  virtual bool DrainDevice(void);
public:
  virtual int64_t GetSTC(void);
  virtual bool IsPlayingVideo(void) const { return isPlayingVideo; }
  virtual cRect CanScaleVideo(const cRect &Rect, int Alignment = taCenter) { return cRect::Null; }
  virtual void ScaleVideo(const cRect &Rect = cRect::Null) {}
  virtual bool HasIBPTrickSpeed(void) { return false; }
  virtual void TrickSpeed(int Speed, bool Forward);
  virtual void Clear(void);
  virtual void Play(void);
  virtual void Freeze(void);
  virtual void Mute(void);
  virtual void StillPicture(const uchar *Data, int Length);
  virtual bool Poll(cPoller &Poller, int TimeoutMs = 0);
#ifndef MUTE_DEPRECATED_FLUSH
  [[deprecated("use Drain() instead")]]
#endif
  virtual bool Flush(int TimeoutMs = 0);
  bool Drain(void);
  virtual int PlayPes(const uchar *Data, int Length, bool VideoOnly = false);
  virtual int PlayTs(const uchar *Data, int Length, bool VideoOnly = false);
  bool Replaying(void) const;
  bool Transferring(void) const;
  void StopReplay(void);
  bool AttachPlayer(cPlayer *Player);
  void Detach(cPlayer *Player);
 
// Receiver facilities
 
private:
  mutable cMutex mutexReceiver;
  cReceiver *receiver[MAXRECEIVERS];
public:
  int Priority(bool IgnoreOccupied = false) const;
protected:
  virtual bool OpenDvr(void);
  virtual void CloseDvr(void);
  virtual bool GetTSPacket(uchar *&Data);
public:
  bool Receiving(bool Dummy = false) const;
  bool AttachReceiver(cReceiver *Receiver);
  void Detach(cReceiver *Receiver, bool ReleaseCam = true);
  void DetachAll(int Pid);
  virtual void DetachAllReceivers(void);
  };

 
class cTSBuffer : public cThread {
private:
  int f;
  int deviceNumber;
  int delivered;
  cRingBufferLinear *ringBuffer;
  virtual void Action(void) override;
public:
  cTSBuffer(int File, int Size, int DeviceNumber);
  virtual ~cTSBuffer() override;
  uchar *Get(int *Available = NULL, bool CheckAvailable = false);
  void Skip(int Count);
  };
 
#endif //__DEVICE_H