lib/dvb/idvb.h

   1 #ifndef __dvb_idvb_h
   2 #define __dvb_idvb_h
   3
   4 #ifndef SWIG
   5
   6 #if HAVE_DVB_API_VERSION < 3
   7 #include <ost/frontend.h>
   8 #define FRONTENDPARAMETERS FrontendParameters
   9 #else
  10 #include <linux/dvb/frontend.h>
  11 #define FRONTENDPARAMETERS struct dvb_frontend_parameters
  12 #endif
  13 #include <lib/dvb/frontendparms.h>
  14 #include <lib/base/object.h>
  15 #include <lib/base/ebase.h>
  16 #include <lib/base/elock.h>
  17 #include <lib/service/service.h>
  18 #include <libsig_comp.h>
  19 #include <connection.h>
  20
  21 struct eBouquet
  22 {
  23         std::string m_bouquet_name;
  24         std::string m_filename;  // without path.. just name
  25         typedef std::list<eServiceReference> list;
  26         list m_services;
  27 // the following five methods are implemented in db.cpp
  28         RESULT flushChanges();
  29         RESULT addService(const eServiceReference &);
  30         RESULT removeService(const eServiceReference &);
  31         RESULT moveService(const eServiceReference &, unsigned int);
  32         RESULT setListName(const std::string &name);
  33 };
  34
  35                 /* these structures have by intention no operator int() defined.
  36                    the reason of these structures is to avoid mixing for example
  37                    a onid and a tsid (as there's no general order for them).
  38
  39                    defining an operator int() would implicitely convert values
  40                    between them over the constructor with the int argument.
  41
  42                    'explicit' doesn't here - eTransportStreamID(eOriginalNetworkID(n))
  43                    would still work. */
  44
  45 struct eTransportStreamID
  46 {
  47 private:
  48         int v;
  49 public:
  50         int get() const { return v; }
  51         eTransportStreamID(int i): v(i) { }
  52         eTransportStreamID(): v(-1) { }
  53         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
  54         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
  55         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
  56         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
  57 };
  58
  59 struct eServiceID
  60 {
  61 private:
  62         int v;
  63 public:
  64         int get() const { return v; }
  65         eServiceID(int i): v(i) { }
  66         eServiceID(): v(-1) { }
  67         bool operator == (const eServiceID &c) const { return v == c.v; }
  68         bool operator != (const eServiceID &c) const { return v != c.v; }
  69         bool operator < (const eServiceID &c) const { return v < c.v; }
  70         bool operator > (const eServiceID &c) const { return v > c.v; }
  71 };
  72
  73 struct eOriginalNetworkID
  74 {
  75 private:
  76         int v;
  77 public:
  78         int get() const { return v; }
  79         eOriginalNetworkID(int i): v(i) { }
  80         eOriginalNetworkID(): v(-1) { }
  81         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
  82         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
  83         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
  84         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
  85 };
  86
  87 struct eDVBNamespace
  88 {
  89 private:
  90         int v;
  91 public:
  92         int get() const { return v; }
  93         eDVBNamespace(int i): v(i) { }
  94         eDVBNamespace(): v(-1) { }
  95         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
  96         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
  97         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
  98         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
  99 };
 100
 101 struct eDVBChannelID
 102 {
 103         eDVBNamespace dvbnamespace;
 104         eTransportStreamID transport_stream_id;
 105         eOriginalNetworkID original_network_id;
 106
 107         bool operator==(const eDVBChannelID &c) const
 108         {
 109                 return dvbnamespace == c.dvbnamespace &&
 110                         transport_stream_id == c.transport_stream_id &&
 111                         original_network_id == c.original_network_id;
 112         }
 113
 114         bool operator<(const eDVBChannelID &c) const
 115         {
 116                 if (dvbnamespace < c.dvbnamespace)
 117                         return 1;
 118                 else if (dvbnamespace == c.dvbnamespace)
 119                 {
 120                         if (original_network_id < c.original_network_id)
 121                                 return 1;
 122                         else if (original_network_id == c.original_network_id)
 123                                 if (transport_stream_id < c.transport_stream_id)
 124                                         return 1;
 125                 }
 126                 return 0;
 127         }
 128         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid):
 129                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
 130         {
 131         }
 132         eDVBChannelID():
 133                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
 134         {
 135         }
 136         operator bool() const
 137         {
 138                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
 139         }
 140 };
 141
 142 struct eServiceReferenceDVB: public eServiceReference
 143 {
 144         int getServiceType() const { return data[0]; }
 145         void setServiceType(int service_type) { data[0]=service_type; }
 146
 147         eServiceID getServiceID() const { return eServiceID(data[1]); }
 148         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
 149
 150         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
 151         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
 152
 153         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
 154         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
 155
 156         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
 157         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
 158
 159         eServiceID getParentServiceID() const { return eServiceID(data[5]); }
 160         void setParentServiceID( eServiceID sid ) { data[5]=sid.get(); }
 161
 162         eTransportStreamID getParentTransportStreamID() const { return eTransportStreamID(data[6]); }
 163         void setParentTransportStreamID( eTransportStreamID tsid ) { data[6]=tsid.get(); }
 164
 165         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 166                 :eServiceReference(eServiceReference::idDVB, 0)
 167         {
 168                 setTransportStreamID(transport_stream_id);
 169                 setOriginalNetworkID(original_network_id);
 170                 setDVBNamespace(dvbnamespace);
 171                 setServiceID(service_id);
 172                 setServiceType(service_type);
 173         }
 174
 175         void set(const eDVBChannelID &chid)
 176         {
 177                 setDVBNamespace(chid.dvbnamespace);
 178                 setOriginalNetworkID(chid.original_network_id);
 179                 setTransportStreamID(chid.transport_stream_id);
 180         }
 181
 182         void getChannelID(eDVBChannelID &chid) const
 183         {
 184                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 185         }
 186
 187         eServiceReferenceDVB()
 188                 :eServiceReference(eServiceReference::idDVB, 0)
 189         {
 190         }
 191
 192         eServiceReferenceDVB(const std::string &string)
 193                 :eServiceReference(string)
 194         {
 195         }
 196 };
 197
 198
 199 ////////////////// TODO: we need an interface here, but what exactly?
 200
 201 #include <set>
 202 // btw, still implemented in db.cpp. FIX THIS, TOO.
 203
 204 class eDVBChannelQuery;
 205
 206 class eDVBService: public iStaticServiceInformation
 207 {
 208         DECLARE_REF(eDVBService);
 209 public:
 210         enum cacheID
 211         {
 212                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
 213         };
 214
 215         int getCachePID(cacheID);
 216         void setCachePID(cacheID, int);
 217         bool cacheEmpty() { return m_cache.empty(); }
 218
 219         eDVBService();
 220                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
 221         std::string m_service_name, m_service_name_sort;
 222         std::string m_provider_name;
 223
 224         void genSortName();
 225
 226         int m_flags;
 227         std::set<int> m_ca;
 228         std::map<int,int> m_cache;
 229         virtual ~eDVBService();
 230
 231         eDVBService &operator=(const eDVBService &);
 232
 233         // iStaticServiceInformation
 234         RESULT getName(const eServiceReference &ref, std::string &name);
 235         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 236         bool isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 237
 238                 /* for filtering: */
 239         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 240 };
 241
 242 //////////////////
 243
 244 class iDVBChannel;
 245 class iDVBDemux;
 246 class iDVBFrontendParameters;
 247
 248 class iDVBChannelListQuery: public iObject
 249 {
 250 public:
 251         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 252         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 253 };
 254
 255 class eDVBChannelQuery: public iObject
 256 {
 257         DECLARE_REF(eDVBChannelQuery);
 258 public:
 259         enum
 260         {
 261                 tName,
 262                 tProvider,
 263                 tType,
 264                 tBouquet,
 265                 tSatellitePosition,
 266                 tChannelID,
 267                 tAND,
 268                 tOR
 269         };
 270
 271         int m_type;
 272         int m_inverse;
 273
 274         std::string m_string;
 275         int m_int;
 276         eDVBChannelID m_channelid;
 277
 278                 /* sort is only valid in root, and must be from the enum above. */
 279         int m_sort;
 280         std::string m_bouquet_name;
 281
 282         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 283
 284         ePtr<eDVBChannelQuery> m_p1, m_p2;
 285 };
 286
 287 class iDVBChannelList: public iObject
 288 {
 289 public:
 290         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 291         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 292
 293         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 294
 295         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
 296         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 297         virtual RESULT flush()=0;
 298
 299         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 300
 301         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
 302 };
 303
 304 #endif  // SWIG
 305
 306 class iDVBFrontendParameters: public iObject
 307 {
 308 #ifdef SWIG
 309         iDVBFrontendParameters();
 310         ~iDVBFrontendParameters();
 311 #endif
 312 public:
 313         virtual RESULT getSystem(int &SWIG_OUTPUT) const = 0;
 314         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
 315         virtual RESULT getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
 316         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
 317
 318         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &SWIG_OUTPUT) const = 0;
 319         virtual RESULT getHash(unsigned long &SWIG_OUTPUT) const = 0;
 320 };
 321
 322 #define MAX_DISEQC_LENGTH  16
 323
 324 class eDVBDiseqcCommand
 325 {
 326 #ifndef SWIG
 327 public:
 328 #endif
 329         int len;
 330         __u8 data[MAX_DISEQC_LENGTH];
 331 #if HAVE_DVB_API_VERSION < 3
 332         int tone;
 333         int voltage;
 334 #endif
 335 #ifdef SWIG
 336 public:
 337 #endif
 338         void setCommandString(const char *str);
 339 };
 340
 341 class iDVBSatelliteEquipmentControl;
 342 class eSecCommandList;
 343
 344 class iDVBFrontend: public iObject
 345 {
 346 public:
 347         enum {
 348                 feSatellite, feCable, feTerrestrial
 349         };
 350         virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0;
 351         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 352 #ifndef SWIG
 353         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 354 #endif
 355         enum {
 356                 stateIdle = 0,
 357                 stateTuning = 1,
 358                 stateFailed = 2,
 359                 stateLock = 3,
 360                 stateLostLock = 4,
 361         };
 362         virtual RESULT getState(int &SWIG_OUTPUT)=0;
 363         enum {
 364                 toneOff, toneOn
 365         };
 366         virtual RESULT setTone(int tone)=0;
 367         enum {
 368                 voltageOff, voltage13, voltage18, voltage13_5, voltage18_5
 369         };
 370         virtual RESULT setVoltage(int voltage)=0;
 371         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 372         virtual RESULT sendToneburst(int burst)=0;
 373 #ifndef SWIG
 374         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 375         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 376 #endif
 377         enum {
 378                 bitErrorRate, signalPower, signalQuality, Locked, Synced
 379         };
 380         virtual int readFrontendData(int type)=0;
 381         virtual PyObject *readTransponderData(bool original)=0;
 382
 383 #ifndef SWIG
 384         virtual RESULT getData(int num, int &data)=0;
 385         virtual RESULT setData(int num, int val)=0;
 386                 /* 0 means: not compatible. other values are a priority. */
 387         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 388 #endif
 389 };
 390 TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
 391
 392 #ifndef SWIG
 393 class iDVBSatelliteEquipmentControl: public iObject
 394 {
 395 public:
 396         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 397         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 398         virtual void setRotorMoving(bool)=0;
 399 };
 400
 401 struct eDVBCIRouting
 402 {
 403         int enabled;
 404 };
 405 #endif // SWIG
 406
 407 class iDVBChannel: public iObject
 408 {
 409 public:
 410         enum
 411         {
 412                 state_idle,        /* not yet tuned */
 413                 state_tuning,      /* currently tuning (first time) */
 414                 state_failed,      /* tuning failed. */
 415                 state_unavailable, /* currently unavailable, will be back without further interaction */
 416                 state_ok,          /* ok */
 417                 state_last_instance, /* just one reference to this channel is left */
 418                 state_release      /* channel is being shut down. */
 419         };
 420         virtual RESULT getState(int &SWIG_OUTPUT)=0;
 421
 422                 /* direct frontend access for raw channels and/or status inquiries. */
 423         virtual RESULT getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
 424
 425 #ifndef SWIG
 426         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
 427         enum
 428         {
 429                 evtEOF, evtSOF, evtFailed
 430         };
 431         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 432         virtual RESULT connectEvent(const Slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
 433
 434                 /* demux capabilities */
 435         enum
 436         {
 437                 capDecode = 1,
 438                 /* capCI = 2 */
 439         };
 440         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 441         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 442
 443                 /* use count handling */
 444         virtual void AddUse() = 0;
 445         virtual void ReleaseUse() = 0;
 446 #endif
 447 };
 448 TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
 449
 450 #ifndef SWIG
 451
 452         /* signed, so we can express deltas. */
 453
 454 typedef long long pts_t;
 455
 456 class iFilePushScatterGather;
 457 class iTSMPEGDecoder;
 458
 459         /* note that a cue sheet describes the logical positions. thus
 460            everything is specified in pts and not file positions */
 461
 462         /* implemented in dvb.cpp */
 463 class eCueSheet: public iObject, public Object
 464 {
 465         DECLARE_REF(eCueSheet);
 466 public:
 467         eCueSheet();
 468
 469                         /* frontend */
 470         void seekTo(int relative, const pts_t &pts);
 471
 472         void clear();
 473         void addSourceSpan(const pts_t &begin, const pts_t &end);
 474         void commitSpans();
 475
 476         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
 477         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
 478
 479                         /* frontend and backend */
 480         eSingleLock m_lock;
 481
 482                         /* backend */
 483         enum { evtSeek, evtSkipmode, evtSpanChanged };
 484         RESULT connectEvent(const Slot1<void, int> &event, ePtr<eConnection> &connection);
 485
 486         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
 487         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
 488         pts_t m_skipmode_ratio;
 489         Signal1<void,int> m_event;
 490         ePtr<iDVBDemux> m_decoding_demux;
 491         ePtr<iTSMPEGDecoder> m_decoder;
 492 };
 493
 494 class iDVBPVRChannel: public iDVBChannel
 495 {
 496 public:
 497         enum
 498         {
 499                 state_eof = state_release + 1  /* end-of-file reached. */
 500         };
 501
 502                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 503                 /* so this is VERY UGLY.
 504
 505                    ok, it's going to get better. but still...*/
 506         virtual RESULT playFile(const char *file) = 0;
 507         virtual void stopFile() = 0;
 508
 509         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
 510
 511         virtual RESULT getLength(pts_t &pts) = 0;
 512
 513                 /* we explicitely ask for the decoding demux here because a channel
 514                    can be shared between multiple decoders.
 515                 */
 516         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
 517                 /* skipping must be done with a cue sheet */
 518 };
 519
 520 class iDVBSectionReader;
 521 class iDVBTSRecorder;
 522 class iTSMPEGDecoder;
 523
 524 class iDVBDemux: public iObject
 525 {
 526 public:
 527         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 528         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 529         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 530         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
 531         virtual RESULT getCADemuxID(uint8_t &id)=0;
 532         virtual RESULT flush()=0;
 533 };
 534
 535 class iTSMPEGDecoder: public iObject
 536 {
 537 public:
 538         enum { pidDisabled = -1 };
 539                 /** Set Displayed Video PID */
 540         virtual RESULT setVideoPID(int vpid)=0;
 541
 542         enum { af_MPEG, af_AC3, af_DTS };
 543                 /** Set Displayed Audio PID and type */
 544         virtual RESULT setAudioPID(int apid, int type)=0;
 545
 546                 /** Set Displayed Videotext PID */
 547         virtual RESULT setTextPID(int vpid)=0;
 548
 549                 /** Set Sync mode to PCR */
 550         virtual RESULT setSyncPCR(int pcrpid)=0;
 551         enum { sm_Audio, sm_Video };
 552                 /** Set Sync mode to either audio or video master */
 553         virtual RESULT setSyncMaster(int who)=0;
 554
 555                 /** Apply settings */
 556         virtual RESULT start()=0;
 557
 558                 /** Freeze frame. Either continue decoding (without display) or halt. */
 559         virtual RESULT freeze(int cont)=0;
 560                 /** Continue after freeze. */
 561         virtual RESULT unfreeze()=0;
 562
 563                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
 564         virtual RESULT setFastForward(int skip=0)=0;
 565
 566                 // stop on .. Picture
 567         enum { spm_I, spm_Ref, spm_Any };
 568                 /** Stop on specific decoded picture. For I-Frame display. */
 569         virtual RESULT setSinglePictureMode(int when)=0;
 570
 571         enum { pkm_B, pkm_PB };
 572                 /** Fast forward by skipping either B or P/B pictures */
 573         virtual RESULT setPictureSkipMode(int what)=0;
 574
 575                 /** Slow Motion by repeating pictures */
 576         virtual RESULT setSlowMotion(int repeat)=0;
 577
 578         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 579                 /** Set Zoom. mode *must* be fitting. */
 580         virtual RESULT setZoom(int what)=0;
 581
 582         virtual RESULT setTrickmode(int what) = 0;
 583
 584         virtual RESULT getPTS(int what, pts_t &pts) = 0;
 585 };
 586
 587 #endif //SWIG
 588 #endif