d5f399c077069454160c6a9a08dba979cc56bb65
[enigma2.git] / 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 };
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 PyObject *readTransponderData(bool original)=0;
469 #ifndef SWIG
470         virtual RESULT getData(int num, int &data)=0;
471         virtual RESULT setData(int num, int val)=0;
472                 /* 0 means: not compatible. other values are a priority. */
473         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
474 #endif
475 };
476 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
477
478 #ifndef SWIG
479 class iDVBSatelliteEquipmentControl: public iObject
480 {
481 public:
482         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
483         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
484         virtual void setRotorMoving(bool)=0;
485 };
486
487 struct eDVBCIRouting
488 {
489         int enabled;
490 };
491 #endif // SWIG
492
493 SWIG_IGNORE(iDVBChannel);
494 class iDVBChannel: public iObject
495 {
496 public:
497                 /* direct frontend access for raw channels and/or status inquiries. */
498         virtual SWIG_VOID(RESULT) getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
499 #ifndef SWIG
500         enum
501         {
502                 state_idle,        /* not yet tuned */
503                 state_tuning,      /* currently tuning (first time) */
504                 state_failed,      /* tuning failed. */
505                 state_unavailable, /* currently unavailable, will be back without further interaction */
506                 state_ok,          /* ok */
507                 state_last_instance, /* just one reference to this channel is left */
508                 state_release      /* channel is being shut down. */
509         };
510         virtual RESULT getState(int &SWIG_OUTPUT)=0;
511
512         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
513         enum 
514         {
515                 evtEOF, evtSOF, evtFailed
516         };
517         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
518         virtual RESULT connectEvent(const Slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
519
520                 /* demux capabilities */
521         enum
522         {
523                 capDecode = 1,
524                 /* capCI = 2 */
525         };
526         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
527         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
528         
529                 /* use count handling */
530         virtual void AddUse() = 0;
531         virtual void ReleaseUse() = 0;
532 #endif
533 };
534 SWIG_TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
535
536 #ifndef SWIG
537         /* signed, so we can express deltas. */
538         
539 typedef long long pts_t;
540
541 class iFilePushScatterGather;
542 class iTSMPEGDecoder;
543
544         /* note that a cue sheet describes the logical positions. thus 
545            everything is specified in pts and not file positions */
546
547         /* implemented in dvb.cpp */
548 class eCueSheet: public iObject, public Object
549 {
550         DECLARE_REF(eCueSheet);
551 public:
552         eCueSheet();
553         
554                         /* frontend */
555         void seekTo(int relative, const pts_t &pts);
556         
557         void clear();
558         void addSourceSpan(const pts_t &begin, const pts_t &end);
559         void commitSpans();
560         
561         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
562         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
563         
564                         /* frontend and backend */
565         eSingleLock m_lock;
566         
567                         /* backend */
568         enum { evtSeek, evtSkipmode, evtSpanChanged };
569         RESULT connectEvent(const Slot1<void, int> &event, ePtr<eConnection> &connection);
570
571         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
572         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
573         pts_t m_skipmode_ratio;
574         Signal1<void,int> m_event;
575         ePtr<iDVBDemux> m_decoding_demux;
576         ePtr<iTSMPEGDecoder> m_decoder;
577 };
578
579 class iDVBPVRChannel: public iDVBChannel
580 {
581 public:
582         enum
583         {
584                 state_eof = state_release + 1  /* end-of-file reached. */
585         };
586         
587                 /* FIXME: there are some very ugly buffer-end and ... related problems */
588                 /* so this is VERY UGLY. 
589                 
590                    ok, it's going to get better. but still...*/
591         virtual RESULT playFile(const char *file) = 0;
592         virtual void stopFile() = 0;
593         
594         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
595         
596         virtual RESULT getLength(pts_t &pts) = 0;
597         
598                 /* we explicitely ask for the decoding demux here because a channel
599                    can be shared between multiple decoders.
600                 */
601         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
602                 /* skipping must be done with a cue sheet */
603 };
604
605 class iDVBSectionReader;
606 class iDVBPESReader;
607 class iDVBTSRecorder;
608 class iTSMPEGDecoder;
609
610 class iDVBDemux: public iObject
611 {
612 public:
613         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
614         virtual RESULT createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader)=0;
615         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
616         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader, int primary=1)=0;
617         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
618         virtual RESULT getCADemuxID(uint8_t &id)=0;
619         virtual RESULT flush()=0;
620 };
621
622 class iTSMPEGDecoder: public iObject
623 {
624 public:
625         enum { pidDisabled = -1 };
626                 /** Set Displayed Video PID and type */
627         virtual RESULT setVideoPID(int vpid, int type)=0;
628
629         enum { af_MPEG, af_AC3, af_DTS, af_AAC };
630                 /** Set Displayed Audio PID and type */
631         virtual RESULT setAudioPID(int apid, int type)=0;
632
633         enum { ac_left, ac_stereo, ac_right };
634                 /** Set Displayed Audio Channel */
635         virtual RESULT setAudioChannel(int channel)=0;
636         virtual int getAudioChannel()=0;
637
638         virtual RESULT setPCMDelay(int delay)=0;
639         virtual int getPCMDelay()=0;
640         virtual RESULT setAC3Delay(int delay)=0;
641         virtual int getAC3Delay()=0;
642
643                 /** Set Displayed Videotext PID */
644         virtual RESULT setTextPID(int vpid)=0;
645
646                 /** Set Sync mode to PCR */
647         virtual RESULT setSyncPCR(int pcrpid)=0;
648         enum { sm_Audio, sm_Video };
649                 /** Set Sync mode to either audio or video master */
650         virtual RESULT setSyncMaster(int who)=0;
651
652                 /** Apply settings */
653         virtual RESULT start()=0;
654         
655                 /** Freeze frame. Either continue decoding (without display) or halt. */
656         virtual RESULT freeze(int cont)=0;
657                 /** Continue after freeze. */
658         virtual RESULT unfreeze()=0;
659         
660                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
661         virtual RESULT setFastForward(int skip=0)=0;
662         
663                 // stop on .. Picture
664         enum { spm_I, spm_Ref, spm_Any };
665                 /** Stop on specific decoded picture. For I-Frame display. */
666         virtual RESULT setSinglePictureMode(int when)=0;
667         
668         enum { pkm_B, pkm_PB };
669                 /** Fast forward by skipping either B or P/B pictures */
670         virtual RESULT setPictureSkipMode(int what)=0;
671         
672                 /** Slow Motion by repeating pictures */
673         virtual RESULT setSlowMotion(int repeat)=0;
674         
675         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
676                 /** Set Zoom. mode *must* be fitting. */
677         virtual RESULT setZoom(int what)=0;
678         
679         virtual RESULT setTrickmode(int what) = 0;
680         
681         virtual RESULT getPTS(int what, pts_t &pts) = 0;
682
683         virtual RESULT showSinglePic(const char *filename) = 0;
684
685         virtual RESULT setRadioPic(const std::string &filename) = 0;
686
687         struct videoEvent
688         {
689                 enum { eventUnknown = 0, eventSizeChanged = VIDEO_EVENT_SIZE_CHANGED } type;
690                 unsigned char aspect;
691                 unsigned short height;
692                 unsigned short width;
693         };
694
695         virtual RESULT connectVideoEvent(const Slot1<void, struct videoEvent> &event, ePtr<eConnection> &connection) = 0;
696 };
697
698 #endif //SWIG
699 #endif