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