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