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