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 1.81 2007/01/13 11:33:57 kls Exp $
 */

#ifndef __DEVICE_H
#define __DEVICE_H

#include "channels.h"
#include "ci.h"
#include "eit.h"
#include "filter.h"
#include "nit.h"
#include "pat.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         5 // used to increase/decrease the volume

#define TS_SIZE          188
#define TS_SYNC_BYTE     0x47
#define PID_MASK_HI      0x1F

enum eSetChannelResult { scrOk, scrNotAvailable, scrNoTransfer, scrFailed };

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 eVideoSystem { vsPAL,
                    vsNTSC
                  };

enum eVideoDisplayFormat { vdfPanAndScan,
                           vdfLetterBox,
                           vdfCenterCutOut
                         };

enum eTrackType { ttNone,
                  ttAudio,
                  ttAudioFirst = ttAudio,
                  ttAudioLast  = ttAudioFirst + 31, // MAXAPIDS - 1
                  ttDolby,
                  ttDolbyFirst = ttDolby,
                  ttDolbyLast  = ttDolbyFirst + 15, // MAXDPIDS - 1
                  /* future...
                  ttSubtitle,
                  ttSubtitleFirst = ttSubtitle,
                  ttSubtitleLast  = ttSubtitleFirst + 7, // MAXSPIDS - 1
                  */
                  ttMaxTrackTypes
                };

#define IS_AUDIO_TRACK(t) (ttAudioFirst <= (t) && (t) <= ttAudioLast)
#define IS_DOLBY_TRACK(t) (ttDolbyFirst <= (t) && (t) <= ttDolbyLast)

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 cPesAssembler;


class cDevice : public cThread {
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);
  static void Shutdown(void);
private:
  static int nextCardIndex;
protected:
  int cardIndex;
  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; }
  int CardIndex(void) const { return cardIndex; }
  int DeviceNumber(void) const;
  virtual bool HasDecoder(void) const;

// SPU facilities

public:
  virtual cSpuDecoder *GetSpuDecoder(void);

// Channel facilities

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 = -1, bool *NeedsDetachReceivers = NULL) const;
  virtual bool IsTunedToTransponder(const cChannel *Channel);
  virtual bool MaySwitchTransponder(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 : 0; }
  static void SetCurrentChannel(const cChannel *Channel) { currentChannel = Channel ? Channel->Number() : 0; }
  void ForceTransferMode(void);
  virtual bool HasLock(int TimeoutMs = 0);
  virtual bool HasProgramme(void);

// PID handle facilities

private:
  virtual void Action(void);
public:
  enum ePidType { ptAudio, ptVideo, ptPcr, ptTeletext, ptDolby, ptOther };
protected:
  class cPidHandle {
  public:
    int pid;
    int handle;
    int used;
    cPidHandle(void) { pid = used = 0; handle = -1; }
    };
  cPidHandle pidHandles[MAXPIDHANDLES];
  bool HasPid(int Pid) const;
public:
  bool AddPid(int Pid, ePidType PidType = ptOther);
protected:
  void DelPid(int Pid, ePidType PidType = ptOther);
  virtual bool SetPid(cPidHandle *Handle, int Type, bool On);

// Section filter facilities

private:
  cSectionHandler *sectionHandler;
  cEitFilter *eitFilter;
  cPatFilter *patFilter;
  cSdtFilter *sdtFilter;
  cNitFilter *nitFilter;
protected:
  void StartSectionHandler(void);
public:
  virtual int OpenFilter(u_short Pid, u_char Tid, u_char Mask);
  virtual void CloseFilter(int Handle);
  void AttachFilter(cFilter *Filter);
  void Detach(cFilter *Filter);

// Common Interface facilities:

private:
  time_t startScrambleDetection;
  cCamSlot *camSlot;
public:
  virtual bool HasCi(void);
  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 eVideoSystem GetVideoSystem(void);

// Track facilities

private:
  tTrackId availableTracks[ttMaxTrackTypes];
  eTrackType currentAudioTrack;
  cMutex mutexCurrentAudioTrack;
  int currentAudioTrackMissingCount;
  bool pre_1_3_19_PrivateStream;
protected:
  virtual void SetAudioTrackDevice(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 NumAudioTracks(void) const;
  eTrackType GetCurrentAudioTrack(void) { return currentAudioTrack; }
  bool SetCurrentAudioTrack(eTrackType Type);
  void EnsureAudioTrack(bool Force = false);

// 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;
  cPesAssembler *pesAssembler;
protected:
  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 PlayPesPacket(const uchar *Data, int Length, bool VideoOnly = false);
public:
  virtual int64_t GetSTC(void);
  virtual void TrickSpeed(int Speed);
  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);
  bool Replaying(void) const;
  bool Transferring(void) const;
  void StopReplay(void);
  bool AttachPlayer(cPlayer *Player);
  void Detach(cPlayer *Player);

// Receiver facilities

private:
  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 CheckAny = false) const;
  bool AttachReceiver(cReceiver *Receiver);
  void Detach(cReceiver *Receiver);
  void DetachAll(int Pid);
  void DetachAllReceivers(void);
  };


class cTSBuffer : public cThread {
private:
  int f;
  int cardIndex;
  bool delivered;
  //cRingBufferLinear *ringBuffer;
  virtual void Action(void);
public:
  cTSBuffer(int File, int Size, int CardIndex);
  ~cTSBuffer();
  uchar *Get(void);
  };

#endif //__DEVICE_H