add demux handling (for decoder and record)
[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         enum cacheID
174         {
175                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
176         };
177
178         int getCachePID(cacheID);
179         void setCachePID(cacheID, int);
180         bool cacheEmpty() { return m_cache.empty(); }
181
182         eDVBService();
183                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
184         std::string m_service_name, m_service_name_sort;
185         std::string m_provider_name;
186         
187         int m_flags;
188         std::set<int> m_ca;
189         std::map<int,int> m_cache;
190         virtual ~eDVBService();
191         
192         eDVBService &operator=(const eDVBService &);
193         
194         // iStaticServiceInformation
195         RESULT getName(const eServiceReference &ref, std::string &name);
196         int getLength(const eServiceReference &ref);
197         
198                 /* for filtering: */
199         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
200 };
201
202 //////////////////
203
204 class iDVBChannel;
205 class iDVBDemux;
206 class iDVBFrontendParameters;
207
208 class iDVBChannelListQuery: public iObject
209 {
210 public:
211         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
212         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
213 };
214
215 class eDVBChannelQuery: public iObject
216 {
217         DECLARE_REF(eDVBChannelQuery);
218 public:
219         enum
220         {
221                 tName,
222                 tProvider,
223                 tType,
224                 tBouquet,
225                 tSatellitePosition,
226                 tChannelID,
227                 tAND,
228                 tOR
229         };
230         
231         int m_type;
232         int m_inverse;
233         
234         std::string m_string;
235         int m_int;
236         eDVBChannelID m_channelid;
237         
238                 /* sort is only valid in root, and must be from the enum above. */
239         int m_sort;
240         
241         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
242         
243         ePtr<eDVBChannelQuery> m_p1, m_p2;
244 };
245
246 class iDVBChannelList: public iObject
247 {
248 public:
249         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
250         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
251         
252         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
253         
254         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
255         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
256
257         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query)=0;
258 };
259
260 class SatelliteDeliverySystemDescriptor;
261 class CableDeliverySystemDescriptor;
262 class TerrestrialDeliverySystemDescriptor;
263
264 struct eDVBFrontendParametersSatellite
265 {
266         struct Polarisation
267         {
268                 enum {
269                         Horizontal, Vertical, CircularLeft, CircularRight
270                 };
271         };
272         struct Inversion
273         {
274                 enum {
275                         On, Off, Unknown
276                 };
277         };
278         struct FEC
279         {
280                 enum {
281                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
282                 };
283         };
284         unsigned int frequency, symbol_rate;
285         int polarisation, fec, inversion, orbital_position;
286         
287         void set(const SatelliteDeliverySystemDescriptor  &);
288 };
289
290 struct eDVBFrontendParametersCable
291 {
292         unsigned int frequency, symbol_rate;
293         int modulation, inversion, fec_inner;
294         void set(const CableDeliverySystemDescriptor  &);
295 };
296
297 struct eDVBFrontendParametersTerrestrial
298 {
299         unsigned int frequency;
300         struct Bandwidth {
301                 enum { Bw8MHz, Bw7MHz, Bw6MHz, BwAuto };
302         };
303         
304         struct FEC
305         {
306                 enum {
307                         fNone, f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
308                 };
309         };
310         
311         struct TransmissionMode {
312                 enum {
313                         TM2k, TM8k, TMAuto
314                 };
315         };
316         
317         struct GuardInterval {
318                 enum {
319                         GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto
320                 };
321         };
322         
323         struct Hierarchy {
324                 enum {
325                         HNone, H1, H2, H4, HAuto
326                 };
327         };
328         
329         struct Modulation {
330                 enum {
331                         QPSK, QAM16, Auto
332                 };
333         };
334
335         struct Inversion
336         {
337                 enum {
338                         On, Off, Unknown
339                 };
340         };
341         
342         int bandwidth;
343         int code_rate_HP, code_rate_LP;
344         int modulation;
345         int transmission_mode;
346         int guard_interval;
347         int hierarchy;
348         int inversion;
349         
350         void set(const TerrestrialDeliverySystemDescriptor  &);
351 };
352
353 class iDVBFrontendParameters: public iObject
354 {
355 public:
356         virtual RESULT getSystem(int &type) const = 0;
357         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
358         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
359         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
360         
361         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
362         virtual RESULT getHash(unsigned long &hash) const = 0;
363 };
364
365 #define MAX_DISEQC_LENGTH  16
366
367 class eDVBDiseqcCommand
368 {
369 public:
370         int len;
371         __u8 data[MAX_DISEQC_LENGTH];
372 #if HAVE_DVB_API_VERSION < 3
373         int tone;
374         int voltage;
375 #endif
376 };
377
378 class iDVBSatelliteEquipmentControl;
379 class eSecCommandList;
380
381 class iDVBFrontend: public iObject
382 {
383 public:
384         enum {
385                 feSatellite, feCable, feTerrestrial
386         };
387         virtual RESULT getFrontendType(int &type)=0;
388         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
389         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
390         enum {
391                 stateIdle = 0,
392                 stateTuning = 1,
393                 stateFailed = 2,
394                 stateLock = 3
395         };
396         virtual RESULT getState(int &state)=0;
397         enum {
398                 toneOff, toneOn
399         };
400         virtual RESULT setTone(int tone)=0;
401         enum {
402                 voltageOff, voltage13, voltage18
403         };
404         virtual RESULT setVoltage(int voltage)=0;
405         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
406         virtual RESULT sendToneburst(int burst)=0;
407         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
408         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
409         virtual RESULT getData(int num, int &data)=0;
410         virtual RESULT setData(int num, int val)=0;
411 };
412
413 class iDVBSatelliteEquipmentControl: public iObject
414 {
415 public:
416         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)=0;
417 };
418
419 struct eDVBCIRouting
420 {
421         int enabled;
422 };
423
424 class iDVBChannel: public iObject
425 {
426 public:
427         enum
428         {
429                 state_idle,        /* not yet tuned */
430                 state_tuning,      /* currently tuning (first time) */
431                 state_unavailable, /* currently unavailable, will be back without further interaction */
432                 state_ok,          /* ok */
433                 state_release      /* channel is being shut down. */
434         };
435         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
436         virtual RESULT getState(int &state)=0;
437         
438                 /* demux capabilities */
439         enum
440         {
441                 capDecode = 1,
442                 /* capCI = 2 */
443         };
444         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
445         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
446         
447                 /* direct frontend access for raw channels and/or status inquiries. */
448         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
449         
450                 /* use count handling */
451         virtual void AddUse() = 0;
452         virtual void ReleaseUse() = 0;
453 };
454
455 typedef unsigned long long pts_t;
456
457 class iDVBPVRChannel: public iDVBChannel
458 {
459 public:
460         enum
461         {
462                 state_eof = state_release + 1  /* end-of-file reached. */
463         };
464         
465                 /* FIXME: there are some very ugly buffer-end and ... related problems */
466                 /* so this is VERY UGLY. */
467         virtual RESULT playFile(const char *file) = 0;
468         
469         virtual RESULT getLength(pts_t &pts) = 0;
470         virtual RESULT getCurrentPosition(pts_t &pos) = 0;
471         
472         // seekTo ...
473 };
474
475 class iDVBSectionReader;
476 class iDVBTSRecorder;
477 class iTSMPEGDecoder;
478
479 class iDVBDemux: public iObject
480 {
481 public:
482         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
483         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
484         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
485         virtual RESULT getSTC(pts_t &pts)=0;
486         virtual RESULT getCADemuxID(uint8_t &id)=0;
487 };
488
489 class iTSMPEGDecoder: public iObject
490 {
491 public:
492         enum { pidDisabled = -1 };
493                 /** Set Displayed Video PID */
494         virtual RESULT setVideoPID(int vpid)=0;
495
496         enum { af_MPEG, af_AC3, af_DTS };
497                 /** Set Displayed Audio PID and type */
498         virtual RESULT setAudioPID(int apid, int type)=0;
499
500                 /** Set Sync mode to PCR */
501         virtual RESULT setSyncPCR(int pcrpid)=0;
502         enum { sm_Audio, sm_Video };
503                 /** Set Sync mode to either audio or video master */
504         virtual RESULT setSyncMaster(int who)=0;
505         
506                 /** Apply settings */
507         virtual RESULT start()=0;
508         
509                 /** Freeze frame. Either continue decoding (without display) or halt. */
510         virtual RESULT freeze(int cont)=0;
511                 /** Continue after freeze. */
512         virtual RESULT unfreeze()=0;
513         
514                 // stop on .. Picture
515         enum { spm_I, spm_Ref, spm_Any };
516                 /** Stop on specific decoded picture. For I-Frame display. */
517         virtual RESULT setSinglePictureMode(int when)=0;
518         
519         enum { pkm_B, pkm_PB };
520                 /** Fast forward by skipping either B or P/B pictures */
521         virtual RESULT setPictureSkipMode(int what)=0;
522         
523                 /** Slow Motion by repeating pictures */
524         virtual RESULT setSlowMotion(int repeat)=0;
525         
526         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
527                 /** Set Zoom. mode *must* be fitting. */
528         virtual RESULT setZoom(int what)=0;
529 };
530
531 #endif