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