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(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 public:
 327         int len;
 328 #ifndef SWIG
 329         __u8 data[MAX_DISEQC_LENGTH];
 330 #if HAVE_DVB_API_VERSION < 3
 331         int tone;
 332         int voltage;
 333 #endif
 334 #endif //SWIG
 335         void setData(const char *str);
 336 };
 337
 338 class iDVBSatelliteEquipmentControl;
 339 class eSecCommandList;
 340
 341 class iDVBFrontend: public iObject
 342 {
 343 public:
 344         enum {
 345                 feSatellite, feCable, feTerrestrial
 346         };
 347         virtual RESULT getFrontendType(int &type)=0;
 348         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 349 #ifndef SWIG
 350         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 351 #endif
 352         enum {
 353                 stateIdle = 0,
 354                 stateTuning = 1,
 355                 stateFailed = 2,
 356                 stateLock = 3,
 357                 stateLostLock = 4,
 358         };
 359         virtual RESULT getState(int &state)=0;
 360         enum {
 361                 toneOff, toneOn
 362         };
 363         virtual RESULT setTone(int tone)=0;
 364         enum {
 365                 voltageOff, voltage13, voltage18, voltage13_5, voltage18_5
 366         };
 367         virtual RESULT setVoltage(int voltage)=0;
 368         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 369         virtual RESULT sendToneburst(int burst)=0;
 370 #ifndef SWIG
 371         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 372         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 373 #endif
 374         enum {
 375                 bitErrorRate, signalPower, signalQuality, Locked, Synced
 376         };
 377         virtual int readFrontendData(int type)=0;
 378         virtual PyObject *readTransponderData(bool original)=0;
 379
 380 #ifndef SWIG
 381         virtual RESULT getData(int num, int &data)=0;
 382         virtual RESULT setData(int num, int val)=0;
 383                 /* 0 means: not compatible. other values are a priority. */
 384         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 385 #endif
 386 };
 387 TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
 388
 389 #ifndef SWIG
 390 class iDVBSatelliteEquipmentControl: public iObject
 391 {
 392 public:
 393         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 394         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 395         virtual void setRotorMoving(bool)=0;
 396 };
 397
 398 struct eDVBCIRouting
 399 {
 400         int enabled;
 401 };
 402 #endif // SWIG
 403
 404 class iDVBChannel: public iObject
 405 {
 406 public:
 407         enum
 408         {
 409                 state_idle,        /* not yet tuned */
 410                 state_tuning,      /* currently tuning (first time) */
 411                 state_failed,      /* tuning failed. */
 412                 state_unavailable, /* currently unavailable, will be back without further interaction */
 413                 state_ok,          /* ok */
 414                 state_last_instance, /* just one reference to this channel is left */
 415                 state_release      /* channel is being shut down. */
 416         };
 417         virtual RESULT getState(int &state)=0;
 418
 419                 /* direct frontend access for raw channels and/or status inquiries. */
 420         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
 421
 422 #ifndef SWIG
 423         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
 424         enum
 425         {
 426                 evtEOF, evtSOF, evtFailed
 427         };
 428         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 429         virtual RESULT connectEvent(const Slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
 430
 431                 /* demux capabilities */
 432         enum
 433         {
 434                 capDecode = 1,
 435                 /* capCI = 2 */
 436         };
 437         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 438         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 439
 440                 /* use count handling */
 441         virtual void AddUse() = 0;
 442         virtual void ReleaseUse() = 0;
 443 #endif
 444 };
 445 TEMPLATE_TYPEDEF(ePtr<iDVBChannel>, iDVBChannelPtr);
 446
 447 #ifndef SWIG
 448
 449         /* signed, so we can express deltas. */
 450
 451 typedef long long pts_t;
 452
 453 class iFilePushScatterGather;
 454 class iTSMPEGDecoder;
 455
 456         /* note that a cue sheet describes the logical positions. thus
 457            everything is specified in pts and not file positions */
 458
 459         /* implemented in dvb.cpp */
 460 class eCueSheet: public iObject, public Object
 461 {
 462         DECLARE_REF(eCueSheet);
 463 public:
 464         eCueSheet();
 465
 466                         /* frontend */
 467         void seekTo(int relative, const pts_t &pts);
 468
 469         void clear();
 470         void addSourceSpan(const pts_t &begin, const pts_t &end);
 471         void commitSpans();
 472
 473         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
 474         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
 475
 476                         /* frontend and backend */
 477         eSingleLock m_lock;
 478
 479                         /* backend */
 480         enum { evtSeek, evtSkipmode, evtSpanChanged };
 481         RESULT connectEvent(const Slot1<void, int> &event, ePtr<eConnection> &connection);
 482
 483         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
 484         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
 485         pts_t m_skipmode_ratio;
 486         Signal1<void,int> m_event;
 487         ePtr<iDVBDemux> m_decoding_demux;
 488         ePtr<iTSMPEGDecoder> m_decoder;
 489 };
 490
 491 class iDVBPVRChannel: public iDVBChannel
 492 {
 493 public:
 494         enum
 495         {
 496                 state_eof = state_release + 1  /* end-of-file reached. */
 497         };
 498
 499                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 500                 /* so this is VERY UGLY.
 501
 502                    ok, it's going to get better. but still...*/
 503         virtual RESULT playFile(const char *file) = 0;
 504         virtual void stopFile() = 0;
 505
 506         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
 507
 508         virtual RESULT getLength(pts_t &pts) = 0;
 509
 510                 /* we explicitely ask for the decoding demux here because a channel
 511                    can be shared between multiple decoders.
 512                 */
 513         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
 514                 /* skipping must be done with a cue sheet */
 515 };
 516
 517 class iDVBSectionReader;
 518 class iDVBTSRecorder;
 519 class iTSMPEGDecoder;
 520
 521 class iDVBDemux: public iObject
 522 {
 523 public:
 524         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 525         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 526         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 527         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
 528         virtual RESULT getCADemuxID(uint8_t &id)=0;
 529         virtual RESULT flush()=0;
 530 };
 531
 532 class iTSMPEGDecoder: public iObject
 533 {
 534 public:
 535         enum { pidDisabled = -1 };
 536                 /** Set Displayed Video PID */
 537         virtual RESULT setVideoPID(int vpid)=0;
 538
 539         enum { af_MPEG, af_AC3, af_DTS };
 540                 /** Set Displayed Audio PID and type */
 541         virtual RESULT setAudioPID(int apid, int type)=0;
 542
 543                 /** Set Displayed Videotext PID */
 544         virtual RESULT setTextPID(int vpid)=0;
 545
 546                 /** Set Sync mode to PCR */
 547         virtual RESULT setSyncPCR(int pcrpid)=0;
 548         enum { sm_Audio, sm_Video };
 549                 /** Set Sync mode to either audio or video master */
 550         virtual RESULT setSyncMaster(int who)=0;
 551
 552                 /** Apply settings */
 553         virtual RESULT start()=0;
 554
 555                 /** Freeze frame. Either continue decoding (without display) or halt. */
 556         virtual RESULT freeze(int cont)=0;
 557                 /** Continue after freeze. */
 558         virtual RESULT unfreeze()=0;
 559
 560                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
 561         virtual RESULT setFastForward(int skip=0)=0;
 562
 563                 // stop on .. Picture
 564         enum { spm_I, spm_Ref, spm_Any };
 565                 /** Stop on specific decoded picture. For I-Frame display. */
 566         virtual RESULT setSinglePictureMode(int when)=0;
 567
 568         enum { pkm_B, pkm_PB };
 569                 /** Fast forward by skipping either B or P/B pictures */
 570         virtual RESULT setPictureSkipMode(int what)=0;
 571
 572                 /** Slow Motion by repeating pictures */
 573         virtual RESULT setSlowMotion(int repeat)=0;
 574
 575         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 576                 /** Set Zoom. mode *must* be fitting. */
 577         virtual RESULT setZoom(int what)=0;
 578
 579         virtual RESULT setTrickmode(int what) = 0;
 580
 581         virtual RESULT getPTS(int what, pts_t &pts) = 0;
 582 };
 583
 584 #endif //SWIG
 585 #endif