4.2.1r3
[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         boost::any getInfoObject(const eServiceReference &ref, int);  // implemented in lib/service/servicedvb.h
366
367                 /* for filtering: */
368         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
369
370
371 };
372
373 //////////////////
374
375 class iDVBChannel;
376 class iDVBDemux;
377 class iDVBFrontendParameters;
378
379 class iDVBChannelListQuery: public iObject
380 {
381 public:
382         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
383         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
384 };
385
386 class eDVBChannelQuery: public iObject
387 {
388         DECLARE_REF(eDVBChannelQuery);
389 public:
390         enum
391         {
392                 tName,
393                 tProvider,
394                 tType,
395                 tBouquet,
396                 tSatellitePosition,
397                 tChannelID,
398                 tAND,
399                 tOR,
400                 tAny,
401                 tNumCAIDs,
402                 tFlags
403         };
404         
405         int m_type;
406         int m_inverse;
407         
408         std::string m_string;
409         int m_int;
410         eDVBChannelID m_channelid;
411         
412                 /* sort is only valid in root, and must be from the enum above. */
413         int m_sort;
414         std::string m_bouquet_name;
415         
416         static RESULT compile(ePtr<eDVBChannelQuery> &res, const std::string &query);
417         
418         ePtr<eDVBChannelQuery> m_p1, m_p2;
419 };
420
421 class iDVBChannelList: public iObject
422 {
423 public:
424         virtual RESULT removeService(const eServiceReference &service)=0;
425         virtual RESULT removeServices(eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0;
426         virtual RESULT removeServices(int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0;
427         virtual RESULT removeServices(iDVBFrontendParameters *feparm)=0;
428         virtual RESULT addFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0;
429         virtual RESULT removeFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0;
430         virtual RESULT removeFlags(unsigned int flagmask, eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0;
431         virtual RESULT removeFlags(unsigned int flagmask, int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0;
432         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
433         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
434         
435         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
436         
437         virtual RESULT addService(const eServiceReferenceDVB &reference, eDVBService *service)=0;
438         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
439         virtual RESULT flush()=0;
440
441         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
442
443         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *q, const eServiceReference &source)=0;
444 };
445
446 #endif  // SWIG
447
448 class iDVBFrontendParameters: public iObject
449 {
450 #ifdef SWIG
451         iDVBFrontendParameters();
452         ~iDVBFrontendParameters();
453 #endif
454 public:
455         enum { flagOnlyFree = 1 };
456         virtual SWIG_VOID(RESULT) getSystem(int &SWIG_OUTPUT) const = 0;
457         virtual SWIG_VOID(RESULT) getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
458         virtual SWIG_VOID(RESULT) getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
459         virtual SWIG_VOID(RESULT) getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
460         virtual SWIG_VOID(RESULT) getFlags(unsigned int &SWIG_OUTPUT) const = 0;
461 #ifndef SWIG
462         virtual SWIG_VOID(RESULT) calculateDifference(const iDVBFrontendParameters *parm, int &, bool exact) const = 0;
463         virtual SWIG_VOID(RESULT) getHash(unsigned long &) const = 0;
464         virtual SWIG_VOID(RESULT) calcLockTimeout(unsigned int &) const = 0;
465 #endif
466 };
467 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontendParameters>, iDVBFrontendParametersPtr);
468
469 #define MAX_DISEQC_LENGTH  16
470
471 class eDVBDiseqcCommand
472 {
473 #ifndef SWIG
474 public:
475 #endif
476         int len;
477         __u8 data[MAX_DISEQC_LENGTH];
478 #ifdef SWIG
479 public:
480 #endif
481         void setCommandString(const char *str);
482 };
483
484 class iDVBSatelliteEquipmentControl;
485 class eSecCommandList;
486
487 class iDVBFrontend_ENUMS
488 {
489 #ifdef SWIG
490         iDVBFrontend_ENUMS();
491         ~iDVBFrontend_ENUMS();
492 #endif
493 public:
494         enum { feSatellite, feCable, feTerrestrial, feSatellite2 };
495         enum { stateIdle, stateTuning, stateFailed, stateLock, stateLostLock, statePreClose, stateClosed };
496         enum { toneOff, toneOn };
497         enum { voltageOff, voltage13, voltage18, voltage13_5, voltage18_5 };
498         enum { bitErrorRate, signalPower, signalQuality, locked, synced, frontendNumber, signalQualitydB };
499 };
500
501 typedef std::map<std::string, int> FrontendDataMap;
502
503 SWIG_IGNORE_ENUMS(iDVBFrontend);
504 class iDVBFrontend: public iDVBFrontend_ENUMS, public iObject
505 {
506 public:
507         virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0;
508         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
509         virtual int closeFrontend(bool force = false, bool no_delayed = false)=0;
510         virtual void reopenFrontend()=0;
511 #ifndef SWIG
512         virtual RESULT connectStateChange(const sigc::slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
513 #endif
514         virtual RESULT getState(int &SWIG_OUTPUT)=0;
515         virtual RESULT setTone(int tone)=0;
516         virtual RESULT setVoltage(int voltage)=0;
517         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
518         virtual RESULT sendToneburst(int burst)=0;
519 #ifndef SWIG
520         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
521         virtual RESULT setSecSequence(eSecCommandList &list)=0;
522 #endif
523         virtual int readFrontendData(int type)=0;
524         virtual RESULT getFrontendStatus(FrontendDataMap &INOUT)=0;
525         virtual RESULT getTransponderData(FrontendDataMap &INOUT, bool original)=0;
526         virtual RESULT getFrontendData(FrontendDataMap &INOUT)=0;
527         virtual eSignal1<void,iDVBFrontend*> &getStateChangeSignal()=0;
528 #ifndef SWIG
529         virtual RESULT getData(int num, long &data)=0;
530         virtual RESULT setData(int num, long val)=0;
531                 /* 0 means: not compatible. other values are a priority. */
532         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
533 #endif
534         virtual bool changeType(int type)=0;
535 };
536 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
537
538 #ifndef SWIG
539 class iDVBSatelliteEquipmentControl: public iObject
540 {
541 public:
542         virtual RESULT prepare(iDVBFrontend &frontend, dvb_frontend_parameters &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id, unsigned int timeout)=0;
543         virtual void prepareClose(iDVBFrontend &frontend)=0;
544         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id, int *highest_score_lnb=0)=0;
545         virtual void setRotorMoving(int slotid, bool)=0;
546 };
547 #endif // SWIG
548
549 SWIG_IGNORE(iDVBChannel);
550 class iDVBChannel: public iObject
551 {
552 public:
553                 /* direct frontend access for raw channels and/or status inquiries. */
554         virtual SWIG_VOID(RESULT) getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
555         virtual RESULT requestTsidOnid(eSlot1<void, int> &callback) { E_UNUSED(callback); return -1; }
556         virtual int reserveDemux() { return -1; }
557 #ifndef SWIG
558         enum
559         {
560                 state_idle,        /* not yet tuned */
561                 state_tuning,      /* currently tuning (first time) */
562                 state_failed,      /* tuning failed. */
563                 state_unavailable, /* currently unavailable, will be back without further interaction */
564                 state_ok,          /* ok */
565                 state_last_instance, /* just one reference to this channel is left */
566                 state_release      /* channel is being shut down. */
567         };
568         virtual RESULT getState(int &)=0;
569
570         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
571         enum 
572         {
573                 evtPreStart, evtEOF, evtSOF, evtFailed
574         };
575         virtual RESULT connectStateChange(const sigc::slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
576         virtual RESULT connectEvent(const sigc::slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
577
578                 /* demux capabilities */
579         enum
580         {
581                 capDecode = 1,
582                 /* capCI = 2 */
583                 capNoDescrambler = 4
584         };
585         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
586         
587                 /* use count handling */
588         virtual void AddUse() = 0;
589         virtual void ReleaseUse() = 0;
590 #endif
591 };
592 SWIG_TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
593
594 #ifndef SWIG
595         /* signed, so we can express deltas. */
596         
597 typedef long long pts_t;
598
599 class iFilePushScatterGather;
600 class iTSMPEGDecoder;
601
602         /* note that a cue sheet describes the logical positions. thus 
603            everything is specified in pts and not file positions */
604
605         /* implemented in dvb.cpp */
606 class eCueSheet: public iObject, public sigc::trackable
607 {
608         DECLARE_REF(eCueSheet);
609 public:
610         eCueSheet();
611         
612                         /* frontend */
613         void seekTo(int relative, const pts_t &pts);
614         
615         void clear();
616         void addSourceSpan(const pts_t &begin, const pts_t &end);
617         void commitSpans();
618         
619         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
620         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
621         
622                         /* frontend and backend */
623         eRdWrLock m_lock;
624         
625                         /* backend */
626         enum { evtSeek, evtSkipmode, evtSpanChanged };
627         RESULT connectEvent(const sigc::slot1<void, int> &event, ePtr<eConnection> &connection);
628
629         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
630         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
631         pts_t m_skipmode_ratio;
632         sigc::signal1<void,int> m_event;
633         ePtr<iDVBDemux> m_decoding_demux;
634         ePtr<iTSMPEGDecoder> m_decoder;
635 };
636
637 class iDVBPVRChannel: public iDVBChannel
638 {
639 public:
640         enum
641         {
642                 state_eof = state_release + 1  /* end-of-file reached. */
643         };
644         
645                 /* FIXME: there are some very ugly buffer-end and ... related problems */
646                 /* so this is VERY UGLY. 
647                 
648                    ok, it's going to get better. but still...*/
649         virtual RESULT playFile(const char *file) = 0;
650         virtual void stopFile() = 0;
651         
652         /* new interface */
653         virtual RESULT playSource(ePtr<iTsSource> &source, const char *priv=NULL) = 0;
654         virtual void stopSource() = 0;
655         
656         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
657         
658         virtual RESULT getLength(pts_t &pts) = 0;
659         
660                 /* we explicitely ask for the decoding demux here because a channel
661                    can be shared between multiple decoders.
662                 */
663         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
664                 /* skipping must be done with a cue sheet */
665 };
666
667 class iDVBSectionReader;
668 class iDVBPESReader;
669 class iDVBTSRecorder;
670 class iTSMPEGDecoder;
671
672 class iDVBDemux: public iObject
673 {
674 public:
675         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
676         virtual RESULT createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader)=0;
677         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
678         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader, int primary=1)=0;
679         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
680         virtual RESULT getCADemuxID(uint8_t &id)=0;
681         virtual RESULT flush()=0;
682         virtual int openDVR(int flags)=0;
683 };
684
685 class iTSMPEGDecoder: public iObject
686 {
687 public:
688         enum { pidDisabled = -1 };
689                 /** Set Displayed Video PID and type */
690         virtual RESULT setVideoPID(int vpid, int type)=0;
691
692         enum { af_MPEG, af_AC3, af_DTS, af_AAC, af_DTSHD };
693                 /** Set Displayed Audio PID and type */
694         virtual RESULT setAudioPID(int apid, int type)=0;
695
696         enum { ac_left, ac_stereo, ac_right };
697                 /** Set Displayed Audio Channel */
698         virtual RESULT setAudioChannel(int channel)=0;
699         virtual int getAudioChannel()=0;
700
701         virtual RESULT setPCMDelay(int delay)=0;
702         virtual int getPCMDelay()=0;
703         virtual RESULT setAC3Delay(int delay)=0;
704         virtual int getAC3Delay()=0;
705
706                 /** Set Displayed Videotext PID */
707         virtual RESULT setTextPID(int vpid)=0;
708
709                 /** Set Sync mode to PCR */
710         virtual RESULT setSyncPCR(int pcrpid)=0;
711         enum { sm_Audio, sm_Video };
712
713                 /** Apply settings but don't change state */
714         virtual RESULT set()=0;
715                 /* all those apply settings, then transition to the given state */
716
717                 /** play */
718         virtual RESULT play()=0;
719                 /** Freeze frame. */
720         virtual RESULT pause()=0;
721
722                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
723         virtual RESULT setFastForward(int skip=0)=0;
724
725                 /** Slow Motion by repeating pictures */
726         virtual RESULT setSlowMotion(int repeat)=0;
727
728                 /** Display any complete data as fast as possible */
729         virtual RESULT setTrickmode()=0;
730         
731         virtual RESULT getPTS(int what, pts_t &pts) = 0;
732
733         virtual RESULT showSinglePic(const char *filename) = 0;
734
735         virtual RESULT setRadioPic(const std::string &filename) = 0;
736
737         struct videoEvent
738         {
739                 enum { eventUnknown = 0,
740                         eventSizeChanged = VIDEO_EVENT_SIZE_CHANGED,
741                         eventFrameRateChanged = VIDEO_EVENT_FRAME_RATE_CHANGED,
742                         eventProgressiveChanged = 16
743                 } type;
744                 unsigned char aspect;
745                 unsigned short height;
746                 unsigned short width;
747                 bool progressive;
748                 unsigned short framerate;
749         };
750
751         virtual RESULT connectVideoEvent(const sigc::slot1<void, struct videoEvent> &event, ePtr<eConnection> &connection) = 0;
752
753         virtual int getVideoWidth() = 0;
754         virtual int getVideoHeight() = 0;
755         virtual int getVideoProgressive() = 0;
756         virtual int getVideoFrameRate() = 0;
757         virtual int getVideoAspect() = 0;
758 };
759
760 #endif //SWIG
761 #endif