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