code.vuplus.com Git - vuplus_dvbapp/blob - 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 getParentServiceReference() const
 166         {
 167                 eServiceReferenceDVB tmp(*this);
 168                 if (data[5] && data[6])
 169                 {
 170                         tmp.data[1] = data[5];
 171                         tmp.data[2] = data[6];
 172                         tmp.data[5] = tmp.data[6] = 0;
 173                 }
 174                 else
 175                         tmp.type = idInvalid;
 176                 return tmp;
 177         }
 178
 179         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 180                 :eServiceReference(eServiceReference::idDVB, 0)
 181         {
 182                 setTransportStreamID(transport_stream_id);
 183                 setOriginalNetworkID(original_network_id);
 184                 setDVBNamespace(dvbnamespace);
 185                 setServiceID(service_id);
 186                 setServiceType(service_type);
 187         }
 188
 189         void set(const eDVBChannelID &chid)
 190         {
 191                 setDVBNamespace(chid.dvbnamespace);
 192                 setOriginalNetworkID(chid.original_network_id);
 193                 setTransportStreamID(chid.transport_stream_id);
 194         }
 195
 196         void getChannelID(eDVBChannelID &chid) const
 197         {
 198                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 199         }
 200
 201         eServiceReferenceDVB()
 202                 :eServiceReference(eServiceReference::idDVB, 0)
 203         {
 204         }
 205
 206         eServiceReferenceDVB(const std::string &string)
 207                 :eServiceReference(string)
 208         {
 209         }
 210 };
 211
 212
 213 ////////////////// TODO: we need an interface here, but what exactly?
 214
 215 #include <set>
 216 // btw, still implemented in db.cpp. FIX THIS, TOO.
 217
 218 class eDVBChannelQuery;
 219
 220 class eDVBService: public iStaticServiceInformation
 221 {
 222         DECLARE_REF(eDVBService);
 223 public:
 224         enum cacheID
 225         {
 226                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
 227         };
 228
 229         int getCachePID(cacheID);
 230         void setCachePID(cacheID, int);
 231         bool cacheEmpty() { return m_cache.empty(); }
 232
 233         eDVBService();
 234                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
 235         std::string m_service_name, m_service_name_sort;
 236         std::string m_provider_name;
 237
 238         void genSortName();
 239
 240         int m_flags;
 241         std::set<int> m_ca;
 242         std::map<int,int> m_cache;
 243         virtual ~eDVBService();
 244
 245         eDVBService &operator=(const eDVBService &);
 246
 247         // iStaticServiceInformation
 248         RESULT getName(const eServiceReference &ref, std::string &name);
 249         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 250         bool isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 251
 252                 /* for filtering: */
 253         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 254 };
 255
 256 //////////////////
 257
 258 class iDVBChannel;
 259 class iDVBDemux;
 260 class iDVBFrontendParameters;
 261
 262 class iDVBChannelListQuery: public iObject
 263 {
 264 public:
 265         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 266         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 267 };
 268
 269 class eDVBChannelQuery: public iObject
 270 {
 271         DECLARE_REF(eDVBChannelQuery);
 272 public:
 273         enum
 274         {
 275                 tName,
 276                 tProvider,
 277                 tType,
 278                 tBouquet,
 279                 tSatellitePosition,
 280                 tChannelID,
 281                 tAND,
 282                 tOR
 283         };
 284
 285         int m_type;
 286         int m_inverse;
 287
 288         std::string m_string;
 289         int m_int;
 290         eDVBChannelID m_channelid;
 291
 292                 /* sort is only valid in root, and must be from the enum above. */
 293         int m_sort;
 294         std::string m_bouquet_name;
 295
 296         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 297
 298         ePtr<eDVBChannelQuery> m_p1, m_p2;
 299 };
 300
 301 class iDVBChannelList: public iObject
 302 {
 303 public:
 304         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 305         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 306
 307         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 308
 309         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
 310         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 311         virtual RESULT flush()=0;
 312
 313         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 314
 315         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
 316 };
 317
 318 #endif  // SWIG
 319
 320 class iDVBFrontendParameters: public iObject
 321 {
 322 #ifdef SWIG
 323         iDVBFrontendParameters();
 324         ~iDVBFrontendParameters();
 325 #endif
 326 public:
 327         virtual RESULT getSystem(int &SWIG_OUTPUT) const = 0;
 328         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
 329         virtual RESULT getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
 330         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
 331
 332         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &SWIG_OUTPUT) const = 0;
 333         virtual RESULT getHash(unsigned long &SWIG_OUTPUT) const = 0;
 334 };
 335
 336 #define MAX_DISEQC_LENGTH  16
 337
 338 class eDVBDiseqcCommand
 339 {
 340 #ifndef SWIG
 341 public:
 342 #endif
 343         int len;
 344         __u8 data[MAX_DISEQC_LENGTH];
 345 #if HAVE_DVB_API_VERSION < 3
 346         int tone;
 347         int voltage;
 348 #endif
 349 #ifdef SWIG
 350 public:
 351 #endif
 352         void setCommandString(const char *str);
 353 };
 354
 355 class iDVBSatelliteEquipmentControl;
 356 class eSecCommandList;
 357
 358 class iDVBFrontend: public iObject
 359 {
 360 public:
 361         enum {
 362                 feSatellite, feCable, feTerrestrial
 363         };
 364         virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0;
 365         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 366 #ifndef SWIG
 367         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 368 #endif
 369         enum {
 370                 stateIdle = 0,
 371                 stateTuning = 1,
 372                 stateFailed = 2,
 373                 stateLock = 3,
 374                 stateLostLock = 4,
 375         };
 376         virtual RESULT getState(int &SWIG_OUTPUT)=0;
 377         enum {
 378                 toneOff, toneOn
 379         };
 380         virtual RESULT setTone(int tone)=0;
 381         enum {
 382                 voltageOff, voltage13, voltage18, voltage13_5, voltage18_5
 383         };
 384         virtual RESULT setVoltage(int voltage)=0;
 385         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 386         virtual RESULT sendToneburst(int burst)=0;
 387 #ifndef SWIG
 388         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 389         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 390 #endif
 391         enum {
 392                 bitErrorRate, signalPower, signalQuality, Locked, Synced
 393         };
 394         virtual int readFrontendData(int type)=0;
 395         virtual PyObject *readTransponderData(bool original)=0;
 396
 397 #ifndef SWIG
 398         virtual RESULT getData(int num, int &data)=0;
 399         virtual RESULT setData(int num, int val)=0;
 400                 /* 0 means: not compatible. other values are a priority. */
 401         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 402 #endif
 403 };
 404 TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
 405
 406 #ifndef SWIG
 407 class iDVBSatelliteEquipmentControl: public iObject
 408 {
 409 public:
 410         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 411         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 412         virtual void setRotorMoving(bool)=0;
 413 };
 414
 415 struct eDVBCIRouting
 416 {
 417         int enabled;
 418 };
 419 #endif // SWIG
 420
 421 class iDVBChannel: public iObject
 422 {
 423 public:
 424         enum
 425         {
 426                 state_idle,        /* not yet tuned */
 427                 state_tuning,      /* currently tuning (first time) */
 428                 state_failed,      /* tuning failed. */
 429                 state_unavailable, /* currently unavailable, will be back without further interaction */
 430                 state_ok,          /* ok */
 431                 state_last_instance, /* just one reference to this channel is left */
 432                 state_release      /* channel is being shut down. */
 433         };
 434         virtual RESULT getState(int &SWIG_OUTPUT)=0;
 435
 436                 /* direct frontend access for raw channels and/or status inquiries. */
 437         virtual RESULT getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
 438
 439 #ifndef SWIG
 440         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
 441         enum
 442         {
 443                 evtEOF, evtSOF, evtFailed
 444         };
 445         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 446         virtual RESULT connectEvent(const Slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
 447
 448                 /* demux capabilities */
 449         enum
 450         {
 451                 capDecode = 1,
 452                 /* capCI = 2 */
 453         };
 454         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 455         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 456
 457                 /* use count handling */
 458         virtual void AddUse() = 0;
 459         virtual void ReleaseUse() = 0;
 460 #endif
 461 };
 462 TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
 463
 464 #ifndef SWIG
 465
 466         /* signed, so we can express deltas. */
 467
 468 typedef long long pts_t;
 469
 470 class iFilePushScatterGather;
 471 class iTSMPEGDecoder;
 472
 473         /* note that a cue sheet describes the logical positions. thus
 474            everything is specified in pts and not file positions */
 475
 476         /* implemented in dvb.cpp */
 477 class eCueSheet: public iObject, public Object
 478 {
 479         DECLARE_REF(eCueSheet);
 480 public:
 481         eCueSheet();
 482
 483                         /* frontend */
 484         void seekTo(int relative, const pts_t &pts);
 485
 486         void clear();
 487         void addSourceSpan(const pts_t &begin, const pts_t &end);
 488         void commitSpans();
 489
 490         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
 491         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
 492
 493                         /* frontend and backend */
 494         eSingleLock m_lock;
 495
 496                         /* backend */
 497         enum { evtSeek, evtSkipmode, evtSpanChanged };
 498         RESULT connectEvent(const Slot1<void, int> &event, ePtr<eConnection> &connection);
 499
 500         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
 501         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
 502         pts_t m_skipmode_ratio;
 503         Signal1<void,int> m_event;
 504         ePtr<iDVBDemux> m_decoding_demux;
 505         ePtr<iTSMPEGDecoder> m_decoder;
 506 };
 507
 508 class iDVBPVRChannel: public iDVBChannel
 509 {
 510 public:
 511         enum
 512         {
 513                 state_eof = state_release + 1  /* end-of-file reached. */
 514         };
 515
 516                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 517                 /* so this is VERY UGLY.
 518
 519                    ok, it's going to get better. but still...*/
 520         virtual RESULT playFile(const char *file) = 0;
 521         virtual void stopFile() = 0;
 522
 523         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
 524
 525         virtual RESULT getLength(pts_t &pts) = 0;
 526
 527                 /* we explicitely ask for the decoding demux here because a channel
 528                    can be shared between multiple decoders.
 529                 */
 530         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
 531                 /* skipping must be done with a cue sheet */
 532 };
 533
 534 class iDVBSectionReader;
 535 class iDVBTSRecorder;
 536 class iTSMPEGDecoder;
 537
 538 class iDVBDemux: public iObject
 539 {
 540 public:
 541         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 542         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 543         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 544         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
 545         virtual RESULT getCADemuxID(uint8_t &id)=0;
 546         virtual RESULT flush()=0;
 547 };
 548
 549 class iTSMPEGDecoder: public iObject
 550 {
 551 public:
 552         enum { pidDisabled = -1 };
 553                 /** Set Displayed Video PID */
 554         virtual RESULT setVideoPID(int vpid)=0;
 555
 556         enum { af_MPEG, af_AC3, af_DTS };
 557                 /** Set Displayed Audio PID and type */
 558         virtual RESULT setAudioPID(int apid, int type)=0;
 559
 560                 /** Set Displayed Videotext PID */
 561         virtual RESULT setTextPID(int vpid)=0;
 562
 563                 /** Set Sync mode to PCR */
 564         virtual RESULT setSyncPCR(int pcrpid)=0;
 565         enum { sm_Audio, sm_Video };
 566                 /** Set Sync mode to either audio or video master */
 567         virtual RESULT setSyncMaster(int who)=0;
 568
 569                 /** Apply settings */
 570         virtual RESULT start()=0;
 571
 572                 /** Freeze frame. Either continue decoding (without display) or halt. */
 573         virtual RESULT freeze(int cont)=0;
 574                 /** Continue after freeze. */
 575         virtual RESULT unfreeze()=0;
 576
 577                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
 578         virtual RESULT setFastForward(int skip=0)=0;
 579
 580                 // stop on .. Picture
 581         enum { spm_I, spm_Ref, spm_Any };
 582                 /** Stop on specific decoded picture. For I-Frame display. */
 583         virtual RESULT setSinglePictureMode(int when)=0;
 584
 585         enum { pkm_B, pkm_PB };
 586                 /** Fast forward by skipping either B or P/B pictures */
 587         virtual RESULT setPictureSkipMode(int what)=0;
 588
 589                 /** Slow Motion by repeating pictures */
 590         virtual RESULT setSlowMotion(int repeat)=0;
 591
 592         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 593                 /** Set Zoom. mode *must* be fitting. */
 594         virtual RESULT setZoom(int what)=0;
 595
 596         virtual RESULT setTrickmode(int what) = 0;
 597
 598         virtual RESULT getPTS(int what, pts_t &pts) = 0;
 599 };
 600
 601 #endif //SWIG
 602 #endif