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