- add eUsePtr for eDVBChannels
[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/base/object.h>
13 #include <lib/base/ebase.h>
14 #include <lib/service/service.h>
15 #include <libsig_comp.h>
16 #include <connection.h>
17
18                 // bitte KEINE operator int() definieren, sonst bringt das ganze nix!
19 struct eTransportStreamID
20 {
21 private:
22         int v;
23 public:
24         int get() const { return v; }
25         eTransportStreamID(int i): v(i) { }
26         eTransportStreamID(): v(-1) { }
27         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
28         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
29         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
30         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
31 };
32
33 struct eServiceID
34 {
35 private:
36         int v;
37 public:
38         int get() const { return v; }
39         eServiceID(int i): v(i) { }
40         eServiceID(): v(-1) { }
41         bool operator == (const eServiceID &c) const { return v == c.v; }
42         bool operator != (const eServiceID &c) const { return v != c.v; }
43         bool operator < (const eServiceID &c) const { return v < c.v; }
44         bool operator > (const eServiceID &c) const { return v > c.v; }
45 };
46
47 struct eOriginalNetworkID
48 {
49 private:
50         int v;
51 public:
52         int get() const { return v; }
53         eOriginalNetworkID(int i): v(i) { }
54         eOriginalNetworkID(): v(-1) { }
55         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
56         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
57         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
58         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
59 };
60
61 struct eDVBNamespace
62 {
63 private:
64         int v;
65 public:
66         int get() const { return v; }
67         eDVBNamespace(int i): v(i) { }
68         eDVBNamespace(): v(-1) { }
69         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
70         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
71         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
72         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
73 };
74
75 struct eDVBChannelID
76 {
77         eDVBNamespace dvbnamespace;
78         eTransportStreamID transport_stream_id;
79         eOriginalNetworkID original_network_id;
80         
81         bool operator==(const eDVBChannelID &c) const
82         {
83                 return dvbnamespace == c.dvbnamespace &&
84                         transport_stream_id == c.transport_stream_id &&
85                         original_network_id == c.original_network_id;
86         }
87         
88         bool operator<(const eDVBChannelID &c) const
89         {
90                 if (dvbnamespace < c.dvbnamespace)
91                         return 1;
92                 else if (dvbnamespace == c.dvbnamespace)
93                 {
94                         if (original_network_id < c.original_network_id)
95                                 return 1;
96                         else if (original_network_id == c.original_network_id)
97                                 if (transport_stream_id < c.transport_stream_id)
98                                         return 1;
99                 }
100                 return 0;
101         }
102         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid): 
103                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
104         {
105         }
106         eDVBChannelID():
107                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
108         {
109         }
110         operator bool() const
111         {
112                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
113         }
114 };
115
116 struct eServiceReferenceDVB: public eServiceReference
117 {
118         int getServiceType() const { return data[0]; }
119         void setServiceType(int service_type) { data[0]=service_type; }
120
121         eServiceID getServiceID() const { return eServiceID(data[1]); }
122         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
123
124         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
125         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
126
127         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
128         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
129
130         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
131         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
132
133         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
134                 :eServiceReference(eServiceReference::idDVB, 0)
135         {
136                 setTransportStreamID(transport_stream_id);
137                 setOriginalNetworkID(original_network_id);
138                 setDVBNamespace(dvbnamespace);
139                 setServiceID(service_id);
140                 setServiceType(service_type);
141         }
142         
143         void set(const eDVBChannelID &chid)
144         {
145                 setDVBNamespace(chid.dvbnamespace);
146                 setOriginalNetworkID(chid.original_network_id);
147                 setTransportStreamID(chid.transport_stream_id);
148         }
149         
150         void getChannelID(eDVBChannelID &chid) const
151         {
152                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
153         }
154
155         eServiceReferenceDVB()
156                 :eServiceReference(eServiceReference::idDVB, 0)
157         {
158         }
159 };
160
161
162 ////////////////// TODO: we need an interface here, but what exactly?
163
164 #include <set>
165 // btw, still implemented in db.cpp. FIX THIS, TOO.
166
167 class eDVBChannelQuery;
168
169 class eDVBService: public iStaticServiceInformation
170 {
171         DECLARE_REF(eDVBService);
172 public:
173         eDVBService();
174         std::string m_service_name;
175         std::string m_provider_name;
176         
177         int m_flags;
178         std::set<int> m_ca;
179         std::map<int,int> m_cache;
180         virtual ~eDVBService();
181         
182         eDVBService &operator=(const eDVBService &);
183         
184         // iStaticServiceInformation
185         RESULT getName(const eServiceReference &ref, std::string &name);
186         
187         // for filtering:
188         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
189 };
190
191 //////////////////
192
193 class iDVBChannel;
194 class iDVBDemux;
195 class iDVBFrontendParameters;
196
197 class iDVBChannelListQuery: public iObject
198 {
199 public:
200         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
201 };
202
203 class eDVBChannelQuery: public iObject
204 {
205         DECLARE_REF(eDVBChannelQuery);
206 public:
207         enum
208         {
209                 tName,
210                 tProvider,
211                 tType,
212                 tBouquet,
213                 tSatellitePosition,
214                 tChannelID,
215                 tAND,
216                 tOR
217         };
218         
219         int m_type;
220         int m_inverse;
221         
222         std::string m_string;
223         int m_int;
224         eDVBChannelID m_channelid;
225         
226         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
227         
228         ePtr<eDVBChannelQuery> m_p1, m_p2;
229 };
230
231 class iDVBChannelList: public iObject
232 {
233 public:
234         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
235         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
236         
237         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
238         
239         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
240         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
241
242         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query)=0;
243 };
244
245 class SatelliteDeliverySystemDescriptor;
246 class CableDeliverySystemDescriptor;
247 class TerrestrialDeliverySystemDescriptor;
248
249 struct eDVBFrontendParametersSatellite
250 {
251         struct Polarisation
252         {
253                 enum {
254                         Horizontal, Vertical, CircularLeft, CircularRight
255                 };
256         };
257         struct Inversion
258         {
259                 enum {
260                         On, Off, Unknown
261                 };
262         };
263         struct FEC
264         {
265                 enum {
266                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
267                 };
268         };
269         unsigned int frequency, symbol_rate;
270         int polarisation, fec, inversion, orbital_position;
271         
272         void set(const SatelliteDeliverySystemDescriptor  &);
273 };
274
275 struct eDVBFrontendParametersCable
276 {
277         unsigned int frequency, symbol_rate;
278         int modulation, inversion, fec_inner;
279         void set(const CableDeliverySystemDescriptor  &);
280 };
281
282 struct eDVBFrontendParametersTerrestrial
283 {
284         unsigned int frequency;
285         struct Bandwidth {
286                 enum { Bw8MHz, Bw7MHz, Bw6MHz, BwAuto };
287         };
288         
289         struct FEC
290         {
291                 enum {
292                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
293                 };
294         };
295         
296         struct TransmissionMode {
297                 enum {
298                         TM2k, TM8k, TMAuto
299                 };
300         };
301         
302         struct GuardInterval {
303                 enum {
304                         GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto
305                 };
306         };
307         
308         struct Hierarchy {
309                 enum {
310                         HNone, H1, H2, H4, HAuto
311                 };
312         };
313         
314         struct Modulation {
315                 enum {
316                         QPSK, QAM16, Auto
317                 };
318         };
319
320         struct Inversion
321         {
322                 enum {
323                         On, Off, Unknown
324                 };
325         };
326         
327         int bandwidth;
328         int code_rate_HP, code_rate_LP;
329         int modulation;
330         int transmission_mode;
331         int guard_interval;
332         int hierarchy;
333         int inversion;
334         
335         void set(const TerrestrialDeliverySystemDescriptor  &);
336 };
337
338 class iDVBFrontendParameters: public iObject
339 {
340 public:
341         virtual RESULT getSystem(int &type) const = 0;
342         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
343         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
344         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
345         
346         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
347         virtual RESULT getHash(unsigned long &hash) const = 0;
348 };
349
350 #define MAX_DISEQC_LENGTH  16
351
352 class eDVBDiseqcCommand
353 {
354 public:
355         int len;
356         __u8 data[MAX_DISEQC_LENGTH];
357 #if HAVE_DVB_API_VERSION < 3
358         int tone;
359         int voltage;
360 #endif
361 };
362
363 class iDVBSatelliteEquipmentControl;
364 class eSecCommandList;
365
366 class iDVBFrontend: public iObject
367 {
368 public:
369         enum {
370                 feSatellite, feCable, feTerrestrial
371         };
372         virtual RESULT getFrontendType(int &type)=0;
373         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
374         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
375         enum {
376                 stateIdle = 0,
377                 stateTuning = 1,
378                 stateFailed = 2,
379                 stateLock = 3
380         };
381         virtual RESULT getState(int &state)=0;
382         enum {
383                 toneOff, toneOn
384         };
385         virtual RESULT setTone(int tone)=0;
386         enum {
387                 voltageOff, voltage13, voltage18
388         };
389         virtual RESULT setVoltage(int voltage)=0;
390         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
391         virtual RESULT sendToneburst(int burst)=0;
392         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
393         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
394         virtual RESULT getData(int num, int &data)=0;
395         virtual RESULT setData(int num, int val)=0;
396 };
397
398 class iDVBSatelliteEquipmentControl: public iObject
399 {
400 public:
401         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)=0;
402 };
403
404 struct eDVBCIRouting
405 {
406         int enabled;
407 };
408
409 class iDVBChannel: public iObject
410 {
411 public:
412         enum
413         {
414                 state_idle,        /* not yet tuned */
415                 state_tuning,      /* currently tuning (first time) */
416                 state_unavailable, /* currently unavailable, will be back without further interaction */
417                 state_ok,          /* ok */
418                 state_release      /* channel is being shut down. */
419         };
420         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
421         virtual RESULT getState(int &state)=0;
422         enum
423         {
424                 cap_decode,
425                 cap_ci
426         };
427         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
428         virtual RESULT getDemux(ePtr<iDVBDemux> &demux)=0;
429         
430                 /* direct frontend access for raw channels and/or status inquiries. */
431         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
432         
433                 /* use count handling */
434         virtual void AddUse() = 0;
435         virtual void ReleaseUse() = 0;
436 };
437
438 class iDVBSectionReader;
439 class iDVBTSRecorder;
440 class iTSMPEGDecoder;
441
442 class iDVBDemux: public iObject
443 {
444 public:
445         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
446         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
447         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
448 };
449
450 class iTSMPEGDecoder: public iObject
451 {
452 public:
453         enum { pidDisabled = -1 };
454                 /** Set Displayed Video PID */
455         virtual RESULT setVideoPID(int vpid)=0;
456
457         enum { af_MPEG, af_AC3, af_DTS };
458                 /** Set Displayed Audio PID and type */
459         virtual RESULT setAudioPID(int apid, int type)=0;
460
461                 /** Set Sync mode to PCR */
462         virtual RESULT setSyncPCR(int pcrpid)=0;
463         enum { sm_Audio, sm_Video };
464                 /** Set Sync mode to either audio or video master */
465         virtual RESULT setSyncMaster(int who)=0;
466         
467                 /** Apply settings */
468         virtual RESULT start()=0;
469         
470                 /** Freeze frame. Either continue decoding (without display) or halt. */
471         virtual RESULT freeze(int cont)=0;
472                 /** Continue after freeze. */
473         virtual RESULT unfreeze()=0;
474         
475                 // stop on .. Picture
476         enum { spm_I, spm_Ref, spm_Any };
477                 /** Stop on specific decoded picture. For I-Frame display. */
478         virtual RESULT setSinglePictureMode(int when)=0;
479         
480         enum { pkm_B, pkm_PB };
481                 /** Fast forward by skipping either B or P/B pictures */
482         virtual RESULT setPictureSkipMode(int what)=0;
483         
484                 /** Slow Motion by repeating pictures */
485         virtual RESULT setSlowMotion(int repeat)=0;
486         
487         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
488                 /** Set Zoom. mode *must* be fitting. */
489         virtual RESULT setZoom(int what)=0;
490 };
491
492 #endif