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