add a blinking point to the infobar
[enigma2.git] / lib / dvb / idvb.h
1 #ifndef __dvb_idvb_h
2 #define __dvb_idvb_h
3
4 #include <config.h>
5 #if HAVE_DVB_API_VERSION < 3
6 #include <ost/frontend.h>
7 #define FRONTENDPARAMETERS FrontendParameters
8 #else
9 #include <linux/dvb/frontend.h>
10 #define FRONTENDPARAMETERS struct dvb_frontend_parameters
11 #endif
12 #include <lib/dvb/frontendparms.h>
13 #include <lib/base/object.h>
14 #include <lib/base/ebase.h>
15 #include <lib/service/service.h>
16 #include <libsig_comp.h>
17 #include <connection.h>
18
19 struct eBouquet
20 {
21         std::string m_bouquet_name;
22         std::string m_path;
23         typedef std::list<eServiceReference> list;
24         list m_services;
25 // the following four methods are implemented in db.cpp
26         RESULT flushChanges();
27         RESULT addService(const eServiceReference &);
28         RESULT removeService(const eServiceReference &);
29         RESULT moveService(const eServiceReference &, unsigned int);
30 };
31
32                 /* these structures have by intention no operator int() defined.
33                    the reason of these structures is to avoid mixing for example
34                    a onid and a tsid (as there's no general order for them).
35                    
36                    defining an operator int() would implicitely convert values
37                    between them over the constructor with the int argument.
38                    
39                    'explicit' doesn't here - eTransportStreamID(eOriginalNetworkID(n)) 
40                    would still work. */
41
42 struct eTransportStreamID
43 {
44 private:
45         int v;
46 public:
47         int get() const { return v; }
48         eTransportStreamID(int i): v(i) { }
49         eTransportStreamID(): v(-1) { }
50         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
51         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
52         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
53         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
54 };
55
56 struct eServiceID
57 {
58 private:
59         int v;
60 public:
61         int get() const { return v; }
62         eServiceID(int i): v(i) { }
63         eServiceID(): v(-1) { }
64         bool operator == (const eServiceID &c) const { return v == c.v; }
65         bool operator != (const eServiceID &c) const { return v != c.v; }
66         bool operator < (const eServiceID &c) const { return v < c.v; }
67         bool operator > (const eServiceID &c) const { return v > c.v; }
68 };
69
70 struct eOriginalNetworkID
71 {
72 private:
73         int v;
74 public:
75         int get() const { return v; }
76         eOriginalNetworkID(int i): v(i) { }
77         eOriginalNetworkID(): v(-1) { }
78         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
79         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
80         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
81         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
82 };
83
84 struct eDVBNamespace
85 {
86 private:
87         int v;
88 public:
89         int get() const { return v; }
90         eDVBNamespace(int i): v(i) { }
91         eDVBNamespace(): v(-1) { }
92         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
93         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
94         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
95         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
96 };
97
98 struct eDVBChannelID
99 {
100         eDVBNamespace dvbnamespace;
101         eTransportStreamID transport_stream_id;
102         eOriginalNetworkID original_network_id;
103         
104         bool operator==(const eDVBChannelID &c) const
105         {
106                 return dvbnamespace == c.dvbnamespace &&
107                         transport_stream_id == c.transport_stream_id &&
108                         original_network_id == c.original_network_id;
109         }
110         
111         bool operator<(const eDVBChannelID &c) const
112         {
113                 if (dvbnamespace < c.dvbnamespace)
114                         return 1;
115                 else if (dvbnamespace == c.dvbnamespace)
116                 {
117                         if (original_network_id < c.original_network_id)
118                                 return 1;
119                         else if (original_network_id == c.original_network_id)
120                                 if (transport_stream_id < c.transport_stream_id)
121                                         return 1;
122                 }
123                 return 0;
124         }
125         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid): 
126                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
127         {
128         }
129         eDVBChannelID():
130                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
131         {
132         }
133         operator bool() const
134         {
135                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
136         }
137 };
138
139 struct eServiceReferenceDVB: public eServiceReference
140 {
141         int getServiceType() const { return data[0]; }
142         void setServiceType(int service_type) { data[0]=service_type; }
143
144         eServiceID getServiceID() const { return eServiceID(data[1]); }
145         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
146
147         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
148         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
149
150         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
151         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
152
153         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
154         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
155
156         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
157                 :eServiceReference(eServiceReference::idDVB, 0)
158         {
159                 setTransportStreamID(transport_stream_id);
160                 setOriginalNetworkID(original_network_id);
161                 setDVBNamespace(dvbnamespace);
162                 setServiceID(service_id);
163                 setServiceType(service_type);
164         }
165         
166         void set(const eDVBChannelID &chid)
167         {
168                 setDVBNamespace(chid.dvbnamespace);
169                 setOriginalNetworkID(chid.original_network_id);
170                 setTransportStreamID(chid.transport_stream_id);
171         }
172         
173         void getChannelID(eDVBChannelID &chid) const
174         {
175                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
176         }
177
178         eServiceReferenceDVB()
179                 :eServiceReference(eServiceReference::idDVB, 0)
180         {
181         }
182 };
183
184
185 ////////////////// TODO: we need an interface here, but what exactly?
186
187 #include <set>
188 // btw, still implemented in db.cpp. FIX THIS, TOO.
189
190 class eDVBChannelQuery;
191
192 class eDVBService: public iStaticServiceInformation
193 {
194         DECLARE_REF(eDVBService);
195 public:
196         enum cacheID
197         {
198                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
199         };
200
201         int getCachePID(cacheID);
202         void setCachePID(cacheID, int);
203         bool cacheEmpty() { return m_cache.empty(); }
204
205         eDVBService();
206                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
207         std::string m_service_name, m_service_name_sort;
208         std::string m_provider_name;
209         
210         void genSortName();
211         
212         int m_flags;
213         std::set<int> m_ca;
214         std::map<int,int> m_cache;
215         virtual ~eDVBService();
216         
217         eDVBService &operator=(const eDVBService &);
218         
219         // iStaticServiceInformation
220         RESULT getName(const eServiceReference &ref, std::string &name);
221         int getLength(const eServiceReference &ref);
222         
223                 /* for filtering: */
224         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
225 };
226
227 //////////////////
228
229 class iDVBChannel;
230 class iDVBDemux;
231 class iDVBFrontendParameters;
232
233 class iDVBChannelListQuery: public iObject
234 {
235 public:
236         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
237         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
238 };
239
240 class eDVBChannelQuery: public iObject
241 {
242         DECLARE_REF(eDVBChannelQuery);
243 public:
244         enum
245         {
246                 tName,
247                 tProvider,
248                 tType,
249                 tBouquet,
250                 tSatellitePosition,
251                 tChannelID,
252                 tAND,
253                 tOR
254         };
255         
256         int m_type;
257         int m_inverse;
258         
259         std::string m_string;
260         int m_int;
261         eDVBChannelID m_channelid;
262         
263                 /* sort is only valid in root, and must be from the enum above. */
264         int m_sort;
265         std::string m_bouquet_name;
266         
267         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
268         
269         ePtr<eDVBChannelQuery> m_p1, m_p2;
270 };
271
272 class iDVBChannelList: public iObject
273 {
274 public:
275         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
276         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
277         
278         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
279         
280         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
281         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
282         virtual RESULT flush()=0;
283
284         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
285
286         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
287 };
288
289 class iDVBFrontendParameters: public iObject
290 {
291 public:
292         virtual RESULT getSystem(int &type) const = 0;
293         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
294         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
295         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
296         
297         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
298         virtual RESULT getHash(unsigned long &hash) const = 0;
299 };
300
301 #define MAX_DISEQC_LENGTH  16
302
303 class eDVBDiseqcCommand
304 {
305 public:
306         int len;
307         __u8 data[MAX_DISEQC_LENGTH];
308 #if HAVE_DVB_API_VERSION < 3
309         int tone;
310         int voltage;
311 #endif
312 };
313
314 class iDVBSatelliteEquipmentControl;
315 class eSecCommandList;
316
317 class iDVBFrontend: public iObject
318 {
319 public:
320         enum {
321                 feSatellite, feCable, feTerrestrial
322         };
323         virtual RESULT getFrontendType(int &type)=0;
324         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
325         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
326         enum {
327                 stateIdle = 0,
328                 stateTuning = 1,
329                 stateFailed = 2,
330                 stateLock = 3,
331                 stateLostLock = 4,
332         };
333         virtual RESULT getState(int &state)=0;
334         enum {
335                 toneOff, toneOn
336         };
337         virtual RESULT setTone(int tone)=0;
338         enum {
339                 voltageOff, voltage13, voltage18
340         };
341         virtual RESULT setVoltage(int voltage)=0;
342         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
343         virtual RESULT sendToneburst(int burst)=0;
344         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
345         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
346         virtual RESULT getData(int num, int &data)=0;
347         virtual RESULT setData(int num, int val)=0;
348         
349                 /* 0 means: not compatible. other values are a priority. */
350         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
351 };
352
353 class iDVBSatelliteEquipmentControl: public iObject
354 {
355 public:
356         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
357         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
358 };
359
360 struct eDVBCIRouting
361 {
362         int enabled;
363 };
364
365 class iDVBChannel: public iObject
366 {
367 public:
368         enum
369         {
370                 state_idle,        /* not yet tuned */
371                 state_tuning,      /* currently tuning (first time) */
372                 state_failed,      /* tuning failed. */
373                 state_unavailable, /* currently unavailable, will be back without further interaction */
374                 state_ok,          /* ok */
375                 state_release      /* channel is being shut down. */
376         };
377         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
378         virtual RESULT getState(int &state)=0;
379         
380                 /* demux capabilities */
381         enum
382         {
383                 capDecode = 1,
384                 /* capCI = 2 */
385         };
386         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
387         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
388         
389                 /* direct frontend access for raw channels and/or status inquiries. */
390         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
391         
392                 /* use count handling */
393         virtual void AddUse() = 0;
394         virtual void ReleaseUse() = 0;
395 };
396
397         /* signed, so we can express deltas. */
398 typedef long long pts_t;
399
400 class iDVBPVRChannel: public iDVBChannel
401 {
402 public:
403         enum
404         {
405                 state_eof = state_release + 1  /* end-of-file reached. */
406         };
407         
408                 /* FIXME: there are some very ugly buffer-end and ... related problems */
409                 /* so this is VERY UGLY. */
410         virtual RESULT playFile(const char *file) = 0;
411         
412         virtual RESULT getLength(pts_t &pts) = 0;
413         
414                 /* we explicitely ask for the decoding demux here because a channel
415                    can be shared between multiple decoders.
416                    Of couse skipping doesn't make much sense 
417                    then, but getCurrentPosition does. */
418         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos) = 0;
419         virtual RESULT seekTo(iDVBDemux *decoding_demux, int relative, pts_t &pts) = 0;
420         virtual RESULT seekToPosition(iDVBDemux *decoding_demux, const off_t &pts) = 0;
421 };
422
423 class iDVBSectionReader;
424 class iDVBTSRecorder;
425 class iTSMPEGDecoder;
426
427 class iDVBDemux: public iObject
428 {
429 public:
430         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
431         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
432         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
433         virtual RESULT getSTC(pts_t &pts)=0;
434         virtual RESULT getCADemuxID(uint8_t &id)=0;
435         virtual RESULT flush()=0;
436 };
437
438 class iTSMPEGDecoder: public iObject
439 {
440 public:
441         enum { pidDisabled = -1 };
442                 /** Set Displayed Video PID */
443         virtual RESULT setVideoPID(int vpid)=0;
444
445         enum { af_MPEG, af_AC3, af_DTS };
446                 /** Set Displayed Audio PID and type */
447         virtual RESULT setAudioPID(int apid, int type)=0;
448
449                 /** Set Sync mode to PCR */
450         virtual RESULT setSyncPCR(int pcrpid)=0;
451         enum { sm_Audio, sm_Video };
452                 /** Set Sync mode to either audio or video master */
453         virtual RESULT setSyncMaster(int who)=0;
454         
455                 /** Apply settings */
456         virtual RESULT start()=0;
457         
458                 /** Freeze frame. Either continue decoding (without display) or halt. */
459         virtual RESULT freeze(int cont)=0;
460                 /** Continue after freeze. */
461         virtual RESULT unfreeze()=0;
462         
463                 // stop on .. Picture
464         enum { spm_I, spm_Ref, spm_Any };
465                 /** Stop on specific decoded picture. For I-Frame display. */
466         virtual RESULT setSinglePictureMode(int when)=0;
467         
468         enum { pkm_B, pkm_PB };
469                 /** Fast forward by skipping either B or P/B pictures */
470         virtual RESULT setPictureSkipMode(int what)=0;
471         
472                 /** Slow Motion by repeating pictures */
473         virtual RESULT setSlowMotion(int repeat)=0;
474         
475         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
476                 /** Set Zoom. mode *must* be fitting. */
477         virtual RESULT setZoom(int what)=0;
478 };
479
480 #endif