lib/dvb/idvb.h

   1 #ifndef __dvb_idvb_h
   2 #define __dvb_idvb_h
   3
   4 #include <config.h>
   5 #if HAVE_DVB_API_VERSION < 3
   6 #include <ost/frontend.h>
   7 #define FRONTENDPARAMETERS FrontendParameters
   8 #else
   9 #define FRONTENDPARAMETERS struct frontend_parameters
  10 #endif
  11 #include <lib/base/object.h>
  12 #include <lib/base/ebase.h>
  13 #include <lib/service/service.h>
  14 #include <libsig_comp.h>
  15 #include <connection.h>
  16
  17                 // bitte KEINE operator int() definieren, sonst bringt das ganze nix!
  18 struct eTransportStreamID
  19 {
  20 private:
  21         int v;
  22 public:
  23         int get() const { return v; }
  24         eTransportStreamID(int i): v(i) { }
  25         eTransportStreamID(): v(-1) { }
  26         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
  27         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
  28         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
  29         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
  30 };
  31
  32 struct eServiceID
  33 {
  34 private:
  35         int v;
  36 public:
  37         int get() const { return v; }
  38         eServiceID(int i): v(i) { }
  39         eServiceID(): v(-1) { }
  40         bool operator == (const eServiceID &c) const { return v == c.v; }
  41         bool operator != (const eServiceID &c) const { return v != c.v; }
  42         bool operator < (const eServiceID &c) const { return v < c.v; }
  43         bool operator > (const eServiceID &c) const { return v > c.v; }
  44 };
  45
  46 struct eOriginalNetworkID
  47 {
  48 private:
  49         int v;
  50 public:
  51         int get() const { return v; }
  52         eOriginalNetworkID(int i): v(i) { }
  53         eOriginalNetworkID(): v(-1) { }
  54         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
  55         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
  56         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
  57         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
  58 };
  59
  60 struct eDVBNamespace
  61 {
  62 private:
  63         int v;
  64 public:
  65         int get() const { return v; }
  66         eDVBNamespace(int i): v(i) { }
  67         eDVBNamespace(): v(-1) { }
  68         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
  69         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
  70         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
  71         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
  72 };
  73
  74 struct eDVBChannelID
  75 {
  76         eDVBNamespace dvbnamespace;
  77         eTransportStreamID transport_stream_id;
  78         eOriginalNetworkID original_network_id;
  79         bool operator<(const eDVBChannelID &c) const
  80         {
  81                 if (dvbnamespace < c.dvbnamespace)
  82                         return 1;
  83                 else if (dvbnamespace == c.dvbnamespace)
  84                 {
  85                         if (original_network_id < c.original_network_id)
  86                                 return 1;
  87                         else if (original_network_id == c.original_network_id)
  88                                 if (transport_stream_id < c.transport_stream_id)
  89                                         return 1;
  90                 }
  91                 return 0;
  92         }
  93         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid):
  94                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
  95         {
  96         }
  97         eDVBChannelID():
  98                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
  99         {
 100         }
 101         operator bool() const
 102         {
 103                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
 104         }
 105 };
 106
 107 struct eServiceReferenceDVB: public eServiceReference
 108 {
 109         int getServiceType() const { return data[0]; }
 110         void setServiceType(int service_type) { data[0]=service_type; }
 111
 112         eServiceID getServiceID() const { return eServiceID(data[1]); }
 113         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
 114
 115         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
 116         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
 117
 118         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
 119         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
 120
 121         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
 122         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
 123
 124         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 125                 :eServiceReference(eServiceReference::idDVB, 0)
 126         {
 127                 setTransportStreamID(transport_stream_id);
 128                 setOriginalNetworkID(original_network_id);
 129                 setDVBNamespace(dvbnamespace);
 130                 setServiceID(service_id);
 131                 setServiceType(service_type);
 132         }
 133
 134         void set(const eDVBChannelID &chid)
 135         {
 136                 setDVBNamespace(chid.dvbnamespace);
 137                 setOriginalNetworkID(chid.original_network_id);
 138                 setTransportStreamID(chid.transport_stream_id);
 139         }
 140
 141         void getChannelID(eDVBChannelID &chid)
 142         {
 143                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 144         }
 145
 146         eServiceReferenceDVB()
 147                 :eServiceReference(eServiceReference::idDVB, 0)
 148         {
 149         }
 150 };
 151
 152
 153 class iDVBChannel;
 154 class iDVBDemux;
 155 class iDVBFrontendParameters;
 156
 157 class iDVBChannelList: public iObject
 158 {
 159 public:
 160         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 161 };
 162
 163 class iDVBResourceManager: public iObject
 164 {
 165 public:
 166         /*
 167                         solange rumloopen bis eine resource gefunden wurde, die eine frequenz
 168                         tunen will
 169
 170                         wenn natuerlich sowas schon vorhanden ist, dann einfach ne ref darauf
 171                         geben. (zwei services auf dem gleichen transponder teilen sich einen
 172                         channel)
 173         */
 174         virtual RESULT setChannelList(iDVBChannelList *list)=0;
 175         virtual RESULT getChannelList(ePtr<iDVBChannelList> &list)=0;
 176         virtual RESULT allocateChannel(const eDVBChannelID &channel, ePtr<iDVBChannel> &channel)=0;
 177         virtual RESULT allocateRawChannel(ePtr<iDVBChannel> &channel)=0;
 178         virtual RESULT allocatePVRChannel(int caps)=0;
 179 };
 180
 181 class SatelliteDeliverySystemDescriptor;
 182 class CableDeliverySystemDescriptor;
 183 class TerrestrialDeliverySystemDescriptor;
 184
 185 struct eDVBFrontendParametersSatellite
 186 {
 187         struct Polarisation
 188         {
 189                 enum {
 190                         Horizontal, Vertical, CircularLeft, CircularRight
 191                 };
 192         };
 193         struct Inversion
 194         {
 195                 enum {
 196                         On, Off, Unknown
 197                 };
 198         };
 199         struct FEC
 200         {
 201                 enum {
 202                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
 203                 };
 204         };
 205         unsigned int frequency, symbol_rate;
 206         int polarisation, fec, inversion, orbital_position;
 207
 208         void set(const SatelliteDeliverySystemDescriptor  &);
 209 };
 210
 211 struct eDVBFrontendParametersCable
 212 {
 213         unsigned int frequency, symbol_rate;
 214         int modulation, inversion, fec_inner;
 215         void set(const CableDeliverySystemDescriptor  &);
 216 };
 217
 218 struct eDVBFrontendParametersTerrestrial
 219 {
 220         int unknown;
 221         void set(const TerrestrialDeliverySystemDescriptor  &);
 222 };
 223
 224 class iDVBFrontendParameters: public iObject
 225 {
 226 public:
 227         virtual RESULT getSystem(int &type) const = 0;
 228         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
 229         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
 230         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
 231
 232         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
 233         virtual RESULT getHash(unsigned long &hash) const = 0;
 234 };
 235
 236 #define MAX_DISEQC_LENGTH  16
 237
 238 struct eDVBDiseqcCommand
 239 {
 240         int len;
 241         __u8 data[MAX_DISEQC_LENGTH];
 242 };
 243
 244 class iDVBSatelliteEquipmentControl;
 245
 246 class iDVBFrontend: public iObject
 247 {
 248 public:
 249         enum {
 250                 feSatellite, feCable, feTerrestrial
 251         };
 252         virtual RESULT getFrontendType(int &type)=0;
 253         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 254         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 255         enum {
 256                 stateIdle = 0,
 257                 stateTuning = 1,
 258                 stateFailed = 2,
 259                 stateLock = 3
 260         };
 261         virtual RESULT getState(int &state)=0;
 262         enum {
 263                 toneOn, toneOff
 264         };
 265         virtual RESULT setTone(int tone)=0;
 266         enum {
 267                 voltageOff, voltage13, voltage18
 268         };
 269         virtual RESULT setVoltage(int voltage)=0;
 270         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 271         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 272 };
 273
 274 class iDVBSatelliteEquipmentControl: public iObject
 275 {
 276 public:
 277         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)=0;
 278 };
 279
 280 struct eDVBCIRouting
 281 {
 282         int enabled;
 283 };
 284
 285 class iDVBChannel: public iObject
 286 {
 287 public:
 288         enum
 289         {
 290                 state_idle,        /* not yet tuned */
 291                 state_tuning,      /* currently tuning (first time) */
 292                 state_unavailable, /* currently unavailable, will be back without further interaction */
 293                 state_ok           /* ok */
 294         };
 295         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 296         virtual RESULT getState(int &state)=0;
 297         enum
 298         {
 299                 cap_decode,
 300                 cap_ci
 301         };
 302         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 303         virtual RESULT getDemux(ePtr<iDVBDemux> &demux)=0;
 304
 305                 /* direct frontend access for raw channels and/or status inquiries. */
 306         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
 307 };
 308
 309 class iDVBSectionReader;
 310 class iTSMPEGDecoder;
 311
 312 class iDVBDemux: public iObject
 313 {
 314 public:
 315         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 316         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 317 };
 318
 319 class iTSMPEGDecoder: public iObject
 320 {
 321 public:
 322         enum { pidDisabled = -1 };
 323                 /** Set Displayed Video PID */
 324         virtual RESULT setVideoPID(int vpid)=0;
 325
 326         enum { af_MPEG, af_AC3, af_DTS };
 327                 /** Set Displayed Audio PID and type */
 328         virtual RESULT setAudioPID(int apid, int type)=0;
 329
 330                 /** Set Sync mode to PCR */
 331         virtual RESULT setSyncPCR(int pcrpid)=0;
 332         enum { sm_Audio, sm_Video };
 333                 /** Set Sync mode to either audio or video master */
 334         virtual RESULT setSyncMaster(int who)=0;
 335
 336                 /** Apply settings */
 337         virtual RESULT start()=0;
 338
 339                 /** Freeze frame. Either continue decoding (without display) or halt. */
 340         virtual RESULT freeze(int cont)=0;
 341                 /** Continue after freeze. */
 342         virtual RESULT unfreeze()=0;
 343
 344                 // stop on .. Picture
 345         enum { spm_I, spm_Ref, spm_Any };
 346                 /** Stop on specific decoded picture. For I-Frame display. */
 347         virtual RESULT setSinglePictureMode(int when)=0;
 348
 349         enum { pkm_B, pkm_PB };
 350                 /** Fast forward by skipping either B or P/B pictures */
 351         virtual RESULT setPictureSkipMode(int what)=0;
 352
 353                 /** Slow Motion by repeating pictures */
 354         virtual RESULT setSlowMotion(int repeat)=0;
 355
 356         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 357                 /** Set Zoom. mode *must* be fitting. */
 358         virtual RESULT setZoom(int what)=0;
 359 };
 360
 361 #endif