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