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/dvb/frontendparms.h>
  13 #include <lib/base/object.h>
  14 #include <lib/base/ebase.h>
  15 #include <lib/service/service.h>
  16 #include <libsig_comp.h>
  17 #include <connection.h>
  18
  19 struct eBouquet
  20 {
  21         std::string m_bouquet_name;
  22         std::string m_path;
  23         typedef std::list<eServiceReference> list;
  24         list m_services;
  25 // the following four methods are implemented in db.cpp
  26         RESULT flushChanges();
  27         RESULT addService(const eServiceReference &);
  28         RESULT removeService(const eServiceReference &);
  29         RESULT moveService(const eServiceReference &, unsigned int);
  30 };
  31
  32                 // bitte KEINE operator int() definieren, sonst bringt das ganze nix!
  33 struct eTransportStreamID
  34 {
  35 private:
  36         int v;
  37 public:
  38         int get() const { return v; }
  39         eTransportStreamID(int i): v(i) { }
  40         eTransportStreamID(): v(-1) { }
  41         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
  42         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
  43         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
  44         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
  45 };
  46
  47 struct eServiceID
  48 {
  49 private:
  50         int v;
  51 public:
  52         int get() const { return v; }
  53         eServiceID(int i): v(i) { }
  54         eServiceID(): v(-1) { }
  55         bool operator == (const eServiceID &c) const { return v == c.v; }
  56         bool operator != (const eServiceID &c) const { return v != c.v; }
  57         bool operator < (const eServiceID &c) const { return v < c.v; }
  58         bool operator > (const eServiceID &c) const { return v > c.v; }
  59 };
  60
  61 struct eOriginalNetworkID
  62 {
  63 private:
  64         int v;
  65 public:
  66         int get() const { return v; }
  67         eOriginalNetworkID(int i): v(i) { }
  68         eOriginalNetworkID(): v(-1) { }
  69         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
  70         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
  71         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
  72         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
  73 };
  74
  75 struct eDVBNamespace
  76 {
  77 private:
  78         int v;
  79 public:
  80         int get() const { return v; }
  81         eDVBNamespace(int i): v(i) { }
  82         eDVBNamespace(): v(-1) { }
  83         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
  84         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
  85         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
  86         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
  87 };
  88
  89 struct eDVBChannelID
  90 {
  91         eDVBNamespace dvbnamespace;
  92         eTransportStreamID transport_stream_id;
  93         eOriginalNetworkID original_network_id;
  94
  95         bool operator==(const eDVBChannelID &c) const
  96         {
  97                 return dvbnamespace == c.dvbnamespace &&
  98                         transport_stream_id == c.transport_stream_id &&
  99                         original_network_id == c.original_network_id;
 100         }
 101
 102         bool operator<(const eDVBChannelID &c) const
 103         {
 104                 if (dvbnamespace < c.dvbnamespace)
 105                         return 1;
 106                 else if (dvbnamespace == c.dvbnamespace)
 107                 {
 108                         if (original_network_id < c.original_network_id)
 109                                 return 1;
 110                         else if (original_network_id == c.original_network_id)
 111                                 if (transport_stream_id < c.transport_stream_id)
 112                                         return 1;
 113                 }
 114                 return 0;
 115         }
 116         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid):
 117                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
 118         {
 119         }
 120         eDVBChannelID():
 121                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
 122         {
 123         }
 124         operator bool() const
 125         {
 126                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
 127         }
 128 };
 129
 130 struct eServiceReferenceDVB: public eServiceReference
 131 {
 132         int getServiceType() const { return data[0]; }
 133         void setServiceType(int service_type) { data[0]=service_type; }
 134
 135         eServiceID getServiceID() const { return eServiceID(data[1]); }
 136         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
 137
 138         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
 139         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
 140
 141         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
 142         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
 143
 144         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
 145         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
 146
 147         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 148                 :eServiceReference(eServiceReference::idDVB, 0)
 149         {
 150                 setTransportStreamID(transport_stream_id);
 151                 setOriginalNetworkID(original_network_id);
 152                 setDVBNamespace(dvbnamespace);
 153                 setServiceID(service_id);
 154                 setServiceType(service_type);
 155         }
 156
 157         void set(const eDVBChannelID &chid)
 158         {
 159                 setDVBNamespace(chid.dvbnamespace);
 160                 setOriginalNetworkID(chid.original_network_id);
 161                 setTransportStreamID(chid.transport_stream_id);
 162         }
 163
 164         void getChannelID(eDVBChannelID &chid) const
 165         {
 166                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 167         }
 168
 169         eServiceReferenceDVB()
 170                 :eServiceReference(eServiceReference::idDVB, 0)
 171         {
 172         }
 173 };
 174
 175
 176 ////////////////// TODO: we need an interface here, but what exactly?
 177
 178 #include <set>
 179 // btw, still implemented in db.cpp. FIX THIS, TOO.
 180
 181 class eDVBChannelQuery;
 182
 183 class eDVBService: public iStaticServiceInformation
 184 {
 185         DECLARE_REF(eDVBService);
 186 public:
 187         enum cacheID
 188         {
 189                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
 190         };
 191
 192         int getCachePID(cacheID);
 193         void setCachePID(cacheID, int);
 194         bool cacheEmpty() { return m_cache.empty(); }
 195
 196         eDVBService();
 197                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
 198         std::string m_service_name, m_service_name_sort;
 199         std::string m_provider_name;
 200
 201         int m_flags;
 202         std::set<int> m_ca;
 203         std::map<int,int> m_cache;
 204         virtual ~eDVBService();
 205
 206         eDVBService &operator=(const eDVBService &);
 207
 208         // iStaticServiceInformation
 209         RESULT getName(const eServiceReference &ref, std::string &name);
 210         int getLength(const eServiceReference &ref);
 211
 212                 /* for filtering: */
 213         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 214 };
 215
 216 //////////////////
 217
 218 class iDVBChannel;
 219 class iDVBDemux;
 220 class iDVBFrontendParameters;
 221
 222 class iDVBChannelListQuery: public iObject
 223 {
 224 public:
 225         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 226         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 227 };
 228
 229 class eDVBChannelQuery: public iObject
 230 {
 231         DECLARE_REF(eDVBChannelQuery);
 232 public:
 233         enum
 234         {
 235                 tName,
 236                 tProvider,
 237                 tType,
 238                 tBouquet,
 239                 tSatellitePosition,
 240                 tChannelID,
 241                 tAND,
 242                 tOR
 243         };
 244
 245         int m_type;
 246         int m_inverse;
 247
 248         std::string m_string;
 249         int m_int;
 250         eDVBChannelID m_channelid;
 251
 252                 /* sort is only valid in root, and must be from the enum above. */
 253         int m_sort;
 254         std::string m_bouquet_name;
 255
 256         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 257
 258         ePtr<eDVBChannelQuery> m_p1, m_p2;
 259 };
 260
 261 class iDVBChannelList: public iObject
 262 {
 263 public:
 264         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 265         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 266
 267         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 268
 269         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
 270         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 271
 272         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 273
 274         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
 275 };
 276
 277 class iDVBFrontendParameters: public iObject
 278 {
 279 public:
 280         virtual RESULT getSystem(int &type) const = 0;
 281         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
 282         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
 283         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
 284
 285         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
 286         virtual RESULT getHash(unsigned long &hash) const = 0;
 287 };
 288
 289 #define MAX_DISEQC_LENGTH  16
 290
 291 class eDVBDiseqcCommand
 292 {
 293 public:
 294         int len;
 295         __u8 data[MAX_DISEQC_LENGTH];
 296 #if HAVE_DVB_API_VERSION < 3
 297         int tone;
 298         int voltage;
 299 #endif
 300 };
 301
 302 class iDVBSatelliteEquipmentControl;
 303 class eSecCommandList;
 304
 305 class iDVBFrontend: public iObject
 306 {
 307 public:
 308         enum {
 309                 feSatellite, feCable, feTerrestrial
 310         };
 311         virtual RESULT getFrontendType(int &type)=0;
 312         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 313         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 314         enum {
 315                 stateIdle = 0,
 316                 stateTuning = 1,
 317                 stateFailed = 2,
 318                 stateLock = 3,
 319                 stateLostLock = 4,
 320         };
 321         virtual RESULT getState(int &state)=0;
 322         enum {
 323                 toneOff, toneOn
 324         };
 325         virtual RESULT setTone(int tone)=0;
 326         enum {
 327                 voltageOff, voltage13, voltage18
 328         };
 329         virtual RESULT setVoltage(int voltage)=0;
 330         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 331         virtual RESULT sendToneburst(int burst)=0;
 332         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 333         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 334         virtual RESULT getData(int num, int &data)=0;
 335         virtual RESULT setData(int num, int val)=0;
 336 };
 337
 338 class iDVBSatelliteEquipmentControl: public iObject
 339 {
 340 public:
 341         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)=0;
 342 };
 343
 344 struct eDVBCIRouting
 345 {
 346         int enabled;
 347 };
 348
 349 class iDVBChannel: public iObject
 350 {
 351 public:
 352         enum
 353         {
 354                 state_idle,        /* not yet tuned */
 355                 state_tuning,      /* currently tuning (first time) */
 356                 state_failed,      /* tuning failed. */
 357                 state_unavailable, /* currently unavailable, will be back without further interaction */
 358                 state_ok,          /* ok */
 359                 state_release      /* channel is being shut down. */
 360         };
 361         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 362         virtual RESULT getState(int &state)=0;
 363
 364                 /* demux capabilities */
 365         enum
 366         {
 367                 capDecode = 1,
 368                 /* capCI = 2 */
 369         };
 370         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 371         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 372
 373                 /* direct frontend access for raw channels and/or status inquiries. */
 374         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
 375
 376                 /* use count handling */
 377         virtual void AddUse() = 0;
 378         virtual void ReleaseUse() = 0;
 379 };
 380
 381         /* signed, so we can express deltas. */
 382 typedef long long pts_t;
 383
 384 class iDVBPVRChannel: public iDVBChannel
 385 {
 386 public:
 387         enum
 388         {
 389                 state_eof = state_release + 1  /* end-of-file reached. */
 390         };
 391
 392                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 393                 /* so this is VERY UGLY. */
 394         virtual RESULT playFile(const char *file) = 0;
 395
 396         virtual RESULT getLength(pts_t &pts) = 0;
 397         virtual RESULT getCurrentPosition(pts_t &pos) = 0;
 398         virtual RESULT seekTo(int relative, pts_t &pts) = 0;
 399         virtual RESULT seekToPosition(const off_t &pts) = 0;
 400 };
 401
 402 class iDVBSectionReader;
 403 class iDVBTSRecorder;
 404 class iTSMPEGDecoder;
 405
 406 class iDVBDemux: public iObject
 407 {
 408 public:
 409         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 410         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 411         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 412         virtual RESULT getSTC(pts_t &pts)=0;
 413         virtual RESULT getCADemuxID(uint8_t &id)=0;
 414         virtual RESULT flush()=0;
 415 };
 416
 417 class iTSMPEGDecoder: public iObject
 418 {
 419 public:
 420         enum { pidDisabled = -1 };
 421                 /** Set Displayed Video PID */
 422         virtual RESULT setVideoPID(int vpid)=0;
 423
 424         enum { af_MPEG, af_AC3, af_DTS };
 425                 /** Set Displayed Audio PID and type */
 426         virtual RESULT setAudioPID(int apid, int type)=0;
 427
 428                 /** Set Sync mode to PCR */
 429         virtual RESULT setSyncPCR(int pcrpid)=0;
 430         enum { sm_Audio, sm_Video };
 431                 /** Set Sync mode to either audio or video master */
 432         virtual RESULT setSyncMaster(int who)=0;
 433
 434                 /** Apply settings */
 435         virtual RESULT start()=0;
 436
 437                 /** Freeze frame. Either continue decoding (without display) or halt. */
 438         virtual RESULT freeze(int cont)=0;
 439                 /** Continue after freeze. */
 440         virtual RESULT unfreeze()=0;
 441
 442                 // stop on .. Picture
 443         enum { spm_I, spm_Ref, spm_Any };
 444                 /** Stop on specific decoded picture. For I-Frame display. */
 445         virtual RESULT setSinglePictureMode(int when)=0;
 446
 447         enum { pkm_B, pkm_PB };
 448                 /** Fast forward by skipping either B or P/B pictures */
 449         virtual RESULT setPictureSkipMode(int what)=0;
 450
 451                 /** Slow Motion by repeating pictures */
 452         virtual RESULT setSlowMotion(int repeat)=0;
 453
 454         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 455                 /** Set Zoom. mode *must* be fitting. */
 456         virtual RESULT setZoom(int what)=0;
 457 };
 458
 459 #endif