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