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