nicer code (api v3 / oldapi)
[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 #define FRONTENDPARAMETERS struct frontend_parameters
10 #endif
11 #include <lib/base/object.h>
12 #include <lib/base/ebase.h>
13 #include <lib/service/service.h>
14 #include <libsig_comp.h>
15 #include <connection.h>
16
17                 // bitte KEINE operator int() definieren, sonst bringt das ganze nix!
18 struct eTransportStreamID
19 {
20 private:
21         int v;
22 public:
23         int get() const { return v; }
24         eTransportStreamID(int i): v(i) { }
25         eTransportStreamID(): v(-1) { }
26         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
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 };
31
32 struct eServiceID
33 {
34 private:
35         int v;
36 public:
37         int get() const { return v; }
38         eServiceID(int i): v(i) { }
39         eServiceID(): v(-1) { }
40         bool operator == (const eServiceID &c) const { return v == c.v; }
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 };
45
46 struct eOriginalNetworkID
47 {
48 private:
49         int v;
50 public:
51         int get() const { return v; }
52         eOriginalNetworkID(int i): v(i) { }
53         eOriginalNetworkID(): v(-1) { }
54         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
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 };
59
60 struct eDVBNamespace
61 {
62 private:
63         int v;
64 public:
65         int get() const { return v; }
66         eDVBNamespace(int i): v(i) { }
67         eDVBNamespace(): v(-1) { }
68         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
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 };
73
74 struct eDVBChannelID
75 {
76         eDVBNamespace dvbnamespace;
77         eTransportStreamID transport_stream_id;
78         eOriginalNetworkID original_network_id;
79         bool operator<(const eDVBChannelID &c) const
80         {
81                 if (dvbnamespace < c.dvbnamespace)
82                         return 1;
83                 else if (dvbnamespace == c.dvbnamespace)
84                 {
85                         if (original_network_id < c.original_network_id)
86                                 return 1;
87                         else if (original_network_id == c.original_network_id)
88                                 if (transport_stream_id < c.transport_stream_id)
89                                         return 1;
90                 }
91                 return 0;
92         }
93         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid): 
94                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
95         {
96         }
97         eDVBChannelID():
98                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
99         {
100         }
101         operator bool() const
102         {
103                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
104         }
105 };
106
107 struct eServiceReferenceDVB: public eServiceReference
108 {
109         int getServiceType() const { return data[0]; }
110         void setServiceType(int service_type) { data[0]=service_type; }
111
112         eServiceID getServiceID() const { return eServiceID(data[1]); }
113         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
114
115         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
116         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
117
118         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
119         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
120
121         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
122         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
123
124         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
125                 :eServiceReference(eServiceReference::idDVB, 0)
126         {
127                 setTransportStreamID(transport_stream_id);
128                 setOriginalNetworkID(original_network_id);
129                 setDVBNamespace(dvbnamespace);
130                 setServiceID(service_id);
131                 setServiceType(service_type);
132         }
133         
134         void set(const eDVBChannelID &chid)
135         {
136                 setDVBNamespace(chid.dvbnamespace);
137                 setOriginalNetworkID(chid.original_network_id);
138                 setTransportStreamID(chid.transport_stream_id);
139         }
140         
141         void getChannelID(eDVBChannelID &chid)
142         {
143                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
144         }
145
146         eServiceReferenceDVB()
147                 :eServiceReference(eServiceReference::idDVB, 0)
148         {
149         }
150 };
151
152
153 class iDVBChannel;
154 class iDVBDemux;
155 class iDVBFrontendParameters;
156
157 class iDVBChannelList: public iObject
158 {
159 public:
160         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
161 };
162
163 class iDVBResourceManager: public iObject
164 {
165 public:
166         /*
167                         solange rumloopen bis eine resource gefunden wurde, die eine frequenz
168                         tunen will
169                         
170                         wenn natuerlich sowas schon vorhanden ist, dann einfach ne ref darauf
171                         geben. (zwei services auf dem gleichen transponder teilen sich einen
172                         channel)
173         */
174         virtual RESULT setChannelList(iDVBChannelList *list)=0;
175         virtual RESULT getChannelList(ePtr<iDVBChannelList> &list)=0;
176         virtual RESULT allocateChannel(const eDVBChannelID &channel, ePtr<iDVBChannel> &channel)=0;
177         virtual RESULT allocateRawChannel(ePtr<iDVBChannel> &channel)=0;
178         virtual RESULT allocatePVRChannel(int caps)=0;
179 };
180
181 class SatelliteDeliverySystemDescriptor;
182 class CableDeliverySystemDescriptor;
183 class TerrestrialDeliverySystemDescriptor;
184
185 struct eDVBFrontendParametersSatellite
186 {
187         struct Polarisation
188         {
189                 enum {
190                         Horizontal, Vertical, CircularLeft, CircularRight
191                 };
192         };
193         struct Inversion
194         {
195                 enum {
196                         On, Off, Unknown
197                 };
198         };
199         struct FEC
200         {
201                 enum {
202                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
203                 };
204         };
205         unsigned int frequency, symbol_rate;
206         int polarisation, fec, inversion, orbital_position;
207         
208         void set(const SatelliteDeliverySystemDescriptor  &);
209 };
210
211 struct eDVBFrontendParametersCable
212 {
213         unsigned int frequency, symbol_rate;
214         int modulation, inversion, fec_inner;
215         void set(const CableDeliverySystemDescriptor  &);
216 };
217
218 struct eDVBFrontendParametersTerrestrial
219 {
220         int unknown;
221         void set(const TerrestrialDeliverySystemDescriptor  &);
222 };
223
224 class iDVBFrontendParameters: public iObject
225 {
226 public:
227         virtual RESULT getSystem(int &type) const = 0;
228         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
229         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
230         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
231         
232         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
233         virtual RESULT getHash(unsigned long &hash) const = 0;
234 };
235
236 #define MAX_DISEQC_LENGTH  16
237
238 struct eDVBDiseqcCommand
239 {
240         int len;
241         __u8 data[MAX_DISEQC_LENGTH];
242 };
243
244 class iDVBSatelliteEquipmentControl;
245
246 class iDVBFrontend: public iObject
247 {
248 public:
249         enum {
250                 feSatellite, feCable, feTerrestrial
251         };
252         virtual RESULT getFrontendType(int &type)=0;
253         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
254         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
255         enum {
256                 stateIdle = 0,
257                 stateTuning = 1,
258                 stateFailed = 2,
259                 stateLock = 3
260         };
261         virtual RESULT getState(int &state)=0;
262         enum {
263                 toneOn, toneOff
264         };
265         virtual RESULT setTone(int tone)=0;
266         enum {
267                 voltageOff, voltage13, voltage18
268         };
269         virtual RESULT setVoltage(int voltage)=0;
270         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
271         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
272 };
273
274 class iDVBSatelliteEquipmentControl: public iObject
275 {
276 public:
277         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)=0;
278 };
279
280 struct eDVBCIRouting
281 {
282         int enabled;
283 };
284
285 class iDVBChannel: public iObject
286 {
287 public:
288         enum
289         {
290                 state_idle,        /* not yet tuned */
291                 state_tuning,      /* currently tuning (first time) */
292                 state_unavailable, /* currently unavailable, will be back without further interaction */
293                 state_ok           /* ok */
294         };
295         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
296         virtual RESULT getState(int &state)=0;
297         enum
298         {
299                 cap_decode,
300                 cap_ci
301         };
302         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
303         virtual RESULT getDemux(ePtr<iDVBDemux> &demux)=0;
304         
305                 /* direct frontend access for raw channels and/or status inquiries. */
306         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
307 };
308
309 class iDVBSectionReader;
310 class iTSMPEGDecoder;
311
312 class iDVBDemux: public iObject
313 {
314 public:
315         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
316         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
317 };
318
319 class iTSMPEGDecoder: public iObject
320 {
321 public:
322         enum { pidDisabled = -1 };
323                 /** Set Displayed Video PID */
324         virtual RESULT setVideoPID(int vpid)=0;
325
326         enum { af_MPEG, af_AC3, af_DTS };
327                 /** Set Displayed Audio PID and type */
328         virtual RESULT setAudioPID(int apid, int type)=0;
329
330                 /** Set Sync mode to PCR */
331         virtual RESULT setSyncPCR(int pcrpid)=0;
332         enum { sm_Audio, sm_Video };
333                 /** Set Sync mode to either audio or video master */
334         virtual RESULT setSyncMaster(int who)=0;
335         
336                 /** Apply settings */
337         virtual RESULT start()=0;
338         
339                 /** Freeze frame. Either continue decoding (without display) or halt. */
340         virtual RESULT freeze(int cont)=0;
341                 /** Continue after freeze. */
342         virtual RESULT unfreeze()=0;
343         
344                 // stop on .. Picture
345         enum { spm_I, spm_Ref, spm_Any };
346                 /** Stop on specific decoded picture. For I-Frame display. */
347         virtual RESULT setSinglePictureMode(int when)=0;
348         
349         enum { pkm_B, pkm_PB };
350                 /** Fast forward by skipping either B or P/B pictures */
351         virtual RESULT setPictureSkipMode(int what)=0;
352         
353                 /** Slow Motion by repeating pictures */
354         virtual RESULT setSlowMotion(int repeat)=0;
355         
356         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
357                 /** Set Zoom. mode *must* be fitting. */
358         virtual RESULT setZoom(int what)=0;
359 };
360
361 #endif