code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/idvb.h

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