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 4.12 2017/11/02 14:47:33 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         16 // 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;
  };


#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();
  virtual bool Ready(void);
  static int NextCardIndex(int n = 0);
  virtual void MakePrimaryDevice(bool On);
public:
  bool IsPrimaryDevice(void) const { return this == primaryDevice && 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;

// SPU facilities

private:
  cLiveSubtitle *liveSubtitle;
  cDvbSubtitleConverter *dvbSubtitleConverter;
public:
  virtual cSpuDecoder *GetSpuDecoder(void);

// Channel facilities

private:
  mutable cMutex mutexChannel;
  time_t occupiedTimeout;
protected:
  static int currentChannel;
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;
  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 : 0; }
#ifndef DEPRECATED_SETCURRENTCHANNEL
#define DEPRECATED_SETCURRENTCHANNEL 1
#endif
#if DEPRECATED_SETCURRENTCHANNEL
  static void SetCurrentChannel(const cChannel *Channel) { currentChannel = Channel ? Channel->Number() : 0; }
#endif
  static void SetCurrentChannel(int ChannelNumber) { currentChannel = ChannelNumber; }
  void ForceTransferMode(void);
  int Occupied(void) const;
  void SetOccupied(int Seconds);
  virtual bool HasLock(int TimeoutMs = 0) const;
  virtual bool HasProgramme(void) const;

// PID handle facilities

private:
  mutable cMutex mutexPids;
  virtual void Action(void);
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);

// Common Interface facilities:

private:
  cCamSlot *camSlot;
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];
  eTrackType currentAudioTrack;
  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);
  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 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:
  cPlayer *player;
  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);
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);
  virtual bool Flush(int TimeoutMs = 0);
  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(void) 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);
  void DetachAll(int Pid);
  virtual void DetachAllReceivers(void);
  };


class cTSBuffer : public cThread {
private:
  int f;
  int cardIndex;
  int delivered;
  cRingBufferLinear *ringBuffer;
  virtual void Action(void);
public:
  cTSBuffer(int File, int Size, int CardIndex);
  virtual ~cTSBuffer();
  uchar *Get(int *Available = NULL, bool CheckAvailable = false);
  void Skip(int Count);
  };

#endif //__DEVICE_H