enigma2: update to 4.3.1r12
[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 };
495         enum { voltageOff, voltage13, voltage18, voltage13_5, voltage18_5 };
496         enum { bitErrorRate, signalPower, signalQuality, locked, synced, frontendNumber, signalQualitydB };
497 };
498
499 typedef std::map<std::string, int> FrontendDataMap;
500
501 SWIG_IGNORE_ENUMS(iDVBFrontend);
502 class iDVBFrontend: public iDVBFrontend_ENUMS, public iObject
503 {
504 public:
505         virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0;
506         virtual RESULT getTunedType(int &SWIG_OUTPUT)=0;
507         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
508         virtual int closeFrontend(bool force = false, bool no_delayed = false)=0;
509         virtual void reopenFrontend()=0;
510 #ifndef SWIG
511         virtual RESULT connectStateChange(const sigc::slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
512 #endif
513         virtual RESULT getState(int &SWIG_OUTPUT)=0;
514         virtual RESULT setTone(int tone)=0;
515         virtual RESULT setVoltage(int voltage, iDVBFrontend *child_fe=NULL)=0;
516         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
517         virtual RESULT sendToneburst(int burst)=0;
518 #ifndef SWIG
519         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
520         virtual RESULT setSecSequence(eSecCommandList &list)=0;
521 #endif
522         virtual int readFrontendData(int type)=0;
523         virtual RESULT getFrontendStatus(FrontendDataMap &INOUT)=0;
524         virtual RESULT getTransponderData(FrontendDataMap &INOUT, bool original)=0;
525         virtual RESULT getFrontendData(FrontendDataMap &INOUT)=0;
526         virtual eSignal1<void,iDVBFrontend*> &getStateChangeSignal()=0;
527 #ifndef SWIG
528         virtual RESULT getData(int num, long &data)=0;
529         virtual RESULT setData(int num, long val)=0;
530                 /* 0 means: not compatible. other values are a priority. */
531         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
532 #endif
533 };
534 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
535
536 #ifndef SWIG
537 class iDVBSatelliteEquipmentControl: public iObject
538 {
539 public:
540         virtual RESULT prepare(iDVBFrontend &frontend, dvb_frontend_parameters &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id, unsigned int timeout)=0;
541         virtual void prepareClose(iDVBFrontend &frontend, bool typeChanged=false)=0;
542         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id, int *highest_score_lnb=0)=0;
543         virtual void setRotorMoving(int slotid, bool)=0;
544 };
545 #endif // SWIG
546
547 SWIG_IGNORE(iDVBChannel);
548 class iDVBChannel: public iObject
549 {
550 public:
551                 /* direct frontend access for raw channels and/or status inquiries. */
552         virtual SWIG_VOID(RESULT) getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
553         virtual RESULT requestTsidOnid(eSlot1<void, int> &callback) { E_UNUSED(callback); return -1; }
554         virtual int reserveDemux() { return -1; }
555 #ifndef SWIG
556         enum
557         {
558                 state_idle,        /* not yet tuned */
559                 state_tuning,      /* currently tuning (first time) */
560                 state_failed,      /* tuning failed. */
561                 state_unavailable, /* currently unavailable, will be back without further interaction */
562                 state_ok,          /* ok */
563                 state_last_instance, /* just one reference to this channel is left */
564                 state_release      /* channel is being shut down. */
565         };
566         virtual RESULT getState(int &)=0;
567
568         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
569         enum 
570         {
571                 evtPreStart, evtEOF, evtSOF, evtFailed
572         };
573         virtual RESULT connectStateChange(const sigc::slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
574         virtual RESULT connectEvent(const sigc::slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
575         virtual RESULT connectSourceEvent(const sigc::slot2<void,int,std::string> &sourceEventChange, ePtr<eConnection> &connection){return -1;};
576
577                 /* demux capabilities */
578         enum
579         {
580                 capDecode = 1,
581                 /* capCI = 2 */
582                 capNoDescrambler = 4
583         };
584         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
585         
586                 /* use count handling */
587         virtual void AddUse() = 0;
588         virtual void ReleaseUse() = 0;
589 #endif
590 };
591 SWIG_TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
592
593 #ifndef SWIG
594         /* signed, so we can express deltas. */
595         
596 typedef long long pts_t;
597
598 class iFilePushScatterGather;
599 class iTSMPEGDecoder;
600
601         /* note that a cue sheet describes the logical positions. thus 
602            everything is specified in pts and not file positions */
603
604         /* implemented in dvb.cpp */
605 class eCueSheet: public iObject, public sigc::trackable
606 {
607         DECLARE_REF(eCueSheet);
608 public:
609         eCueSheet();
610         
611                         /* frontend */
612         void seekTo(int relative, const pts_t &pts);
613         
614         void clear();
615         void addSourceSpan(const pts_t &begin, const pts_t &end);
616         void commitSpans();
617         
618         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
619         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
620         
621                         /* frontend and backend */
622         eRdWrLock m_lock;
623         
624                         /* backend */
625         enum { evtSeek, evtSkipmode, evtSpanChanged };
626         RESULT connectEvent(const sigc::slot1<void, int> &event, ePtr<eConnection> &connection);
627
628         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
629         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
630         pts_t m_skipmode_ratio;
631         sigc::signal1<void,int> m_event;
632         ePtr<iDVBDemux> m_decoding_demux;
633         ePtr<iTSMPEGDecoder> m_decoder;
634 };
635
636 class iDVBPVRChannel: public iDVBChannel
637 {
638 public:
639         enum
640         {
641                 state_eof = state_release + 1  /* end-of-file reached. */
642         };
643         
644                 /* FIXME: there are some very ugly buffer-end and ... related problems */
645                 /* so this is VERY UGLY. 
646                 
647                    ok, it's going to get better. but still...*/
648         virtual RESULT playFile(const char *file) = 0;
649         virtual void stopFile() = 0;
650         
651         /* new interface */
652         virtual RESULT playSource(ePtr<iTsSource> &source, const char *priv=NULL) = 0;
653         virtual void stopSource() = 0;
654         
655         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
656         
657         virtual RESULT getLength(pts_t &pts) = 0;
658         
659                 /* we explicitely ask for the decoding demux here because a channel
660                    can be shared between multiple decoders.
661                 */
662         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
663                 /* skipping must be done with a cue sheet */
664 };
665
666 class iDVBSectionReader;
667 class iDVBPESReader;
668 class iDVBTSRecorder;
669 class iTSMPEGDecoder;
670
671 class iDVBDemux: public iObject
672 {
673 public:
674         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
675         virtual RESULT createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader)=0;
676         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
677         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader, int decoder_id=0)=0;
678         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
679         virtual RESULT getCADemuxID(uint8_t &id)=0;
680         virtual RESULT flush()=0;
681         virtual int openDVR(int flags)=0;
682 };
683
684 class iTSMPEGDecoder: public iObject
685 {
686 public:
687         enum { pidDisabled = -1 };
688                 /** Set Displayed Video PID and type */
689         virtual RESULT setVideoPID(int vpid, int type)=0;
690
691         enum { af_MPEG, af_AC3, af_DTS, af_AAC, af_DTSHD };
692                 /** Set Displayed Audio PID and type */
693         virtual RESULT setAudioPID(int apid, int type)=0;
694
695         enum { ac_left, ac_stereo, ac_right };
696                 /** Set Displayed Audio Channel */
697         virtual RESULT setAudioChannel(int channel)=0;
698         virtual int getAudioChannel()=0;
699
700         virtual RESULT setPCMDelay(int delay)=0;
701         virtual int getPCMDelay()=0;
702         virtual RESULT setAC3Delay(int delay)=0;
703         virtual int getAC3Delay()=0;
704
705                 /** Set Displayed Videotext PID */
706         virtual RESULT setTextPID(int vpid)=0;
707
708                 /** Set Sync mode to PCR */
709         virtual RESULT setSyncPCR(int pcrpid)=0;
710         enum { sm_Audio, sm_Video };
711
712                 /** Apply settings but don't change state */
713         virtual RESULT set()=0;
714                 /* all those apply settings, then transition to the given state */
715
716                 /** play */
717         virtual RESULT play()=0;
718                 /** Freeze frame. */
719         virtual RESULT pause()=0;
720
721                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
722         virtual RESULT setFastForward(int skip=0)=0;
723
724                 /** Slow Motion by repeating pictures */
725         virtual RESULT setSlowMotion(int repeat)=0;
726
727                 /** Display any complete data as fast as possible */
728         virtual RESULT setTrickmode()=0;
729         
730         virtual RESULT getPTS(int what, pts_t &pts) = 0;
731
732         virtual RESULT showSinglePic(const char *filename) = 0;
733
734         virtual RESULT setRadioPic(const std::string &filename) = 0;
735
736         struct videoEvent
737         {
738                 enum { eventUnknown = 0,
739                         eventSizeChanged = VIDEO_EVENT_SIZE_CHANGED,
740                         eventFrameRateChanged = VIDEO_EVENT_FRAME_RATE_CHANGED,
741                         eventProgressiveChanged = 16
742                 } type;
743                 unsigned char aspect;
744                 unsigned short height;
745                 unsigned short width;
746                 bool progressive;
747                 unsigned short framerate;
748         };
749
750         virtual RESULT connectVideoEvent(const sigc::slot1<void, struct videoEvent> &event, ePtr<eConnection> &connection) = 0;
751         virtual RESULT connectStateEvent(const sigc::slot1<void, int> &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         virtual int getState() = 0;
759         virtual const char *getEotf() = 0;
760 };
761
762 #endif //SWIG
763 #endif