fix path to default plugin.png
[enigma2.git] / lib / service / iservice.h
1 #ifndef __lib_dvb_iservice_h
2 #define __lib_dvb_iservice_h
3
4 #include <lib/python/swig.h>
5 #include <lib/python/python.h>
6 #include <lib/base/object.h>
7 #include <string>
8 #include <connection.h>
9 #include <list>
10
11 class eServiceEvent;
12
13 class eServiceReference
14 {
15 public:
16         enum
17         {
18                 idInvalid=-1,
19                 idStructure,    // service_id == 0 is root
20                 idDVB,
21                 idFile,
22                 idUser=0x1000
23         };
24         int type;
25
26         enum
27         {
28                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
29                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
30                 /*
31                         for example:
32                                 normal services have none of them - they can be fed directly into the "play"-handler.
33                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
34                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
35                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
36                 */
37                 canDescent=4,                   // supports enterDirectory/leaveDirectory
38                 flagDirectory=isDirectory|mustDescent|canDescent,
39                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
40                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
41                 sort1=32,                                       // sort key is 1 instead of 0
42                 isMarker=64,                    // Marker
43                 isGroup=128                     // is a group of services
44         };
45         int flags; // flags will NOT be compared.
46
47         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
48
49 #ifndef SWIG
50         int data[8];
51         std::string path;
52 #endif
53         std::string getPath() { return path; }
54         void setPath( const std::string &n ) { path=n; }
55
56         unsigned int getUnsignedData(unsigned int num) const
57         {
58                 if ( num < sizeof(data)/sizeof(int) )
59                         return data[num];
60                 return 0;
61         }
62
63         int getData(unsigned int num) const
64         {
65                 if ( num < sizeof(data)/sizeof(int) )
66                         return data[num];
67                 return 0;
68         }
69
70         void setUnsignedData(unsigned int num, unsigned int val)
71         {
72                 if ( num < sizeof(data)/sizeof(int) )
73                         data[num] = val;
74         }
75
76         void setData(unsigned int num, int val)
77         {
78                 if ( num < sizeof(data)/sizeof(int) )
79                         data[num] = val;
80         }
81
82 // only for override service names in bouquets or to give servicerefs a name which not have a
83 // real existing service ( for dvb eServiceDVB )
84 #ifndef SWIG
85         std::string name;
86 #endif
87         std::string getName() const { return name; }
88         void setName( const std::string &n ) { name=n; }
89
90         eServiceReference()
91                 : type(idInvalid), flags(0)
92         {
93                 memset(data, 0, sizeof(data));
94         }
95 #ifndef SWIG
96         eServiceReference(int type, int flags)
97                 : type(type), flags(flags)
98         {
99                 memset(data, 0, sizeof(data));
100         }
101         eServiceReference(int type, int flags, int data0)
102                 : type(type), flags(flags)
103         {
104                 memset(data, 0, sizeof(data));
105                 data[0]=data0;
106         }
107         eServiceReference(int type, int flags, int data0, int data1)
108                 : type(type), flags(flags)
109         {
110                 memset(data, 0, sizeof(data));
111                 data[0]=data0;
112                 data[1]=data1;
113         }
114         eServiceReference(int type, int flags, int data0, int data1, int data2)
115                 : type(type), flags(flags)
116         {
117                 memset(data, 0, sizeof(data));
118                 data[0]=data0;
119                 data[1]=data1;
120                 data[2]=data2;
121         }
122         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
123                 : type(type), flags(flags)
124         {
125                 memset(data, 0, sizeof(data));
126                 data[0]=data0;
127                 data[1]=data1;
128                 data[2]=data2;
129                 data[3]=data3;
130         }
131         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
132                 : type(type), flags(flags)
133         {
134                 memset(data, 0, sizeof(data));
135                 data[0]=data0;
136                 data[1]=data1;
137                 data[2]=data2;
138                 data[3]=data3;
139                 data[4]=data4;
140         }
141 #endif
142         eServiceReference(int type, int flags, const std::string &path)
143                 : type(type), flags(flags), path(path)
144         {
145                 memset(data, 0, sizeof(data));
146         }
147         eServiceReference(const std::string &string);
148         std::string toString() const;
149         std::string toCompareString() const;
150         bool operator==(const eServiceReference &c) const
151         {
152                 if (type != c.type)
153                         return 0;
154                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
155         }
156         bool operator!=(const eServiceReference &c) const
157         {
158                 return !(*this == c);
159         }
160         bool operator<(const eServiceReference &c) const
161         {
162                 if (type < c.type)
163                         return 1;
164
165                 if (type > c.type)
166                         return 0;
167
168                 int r=memcmp(data, c.data, sizeof(int)*8);
169                 if (r)
170                         return r < 0;
171                 return path < c.path;
172         }
173         operator bool() const
174         {
175                 return valid();
176         }
177         
178         int valid() const
179         {
180                 return type != idInvalid;
181         }
182 };
183
184 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
185
186 extern PyObject *New_eServiceReference(const eServiceReference &ref); // defined in enigma_python.i
187
188 #ifndef SWIG
189 #ifdef PYTHON_REFCOUNT_DEBUG
190 inline ePyObject Impl_New_eServiceReference(const char* file, int line, const eServiceReference &ref)
191 {
192         return ePyObject(New_eServiceReference(ref), file, line);
193 }
194 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(__FILE__, __LINE__, ref)
195 #else
196 inline ePyObject Impl_New_eServiceReference(const eServiceReference &ref)
197 {
198         return New_eServiceReference(ref);
199 }
200 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(ref)
201 #endif
202 #endif // SWIG
203
204 typedef long long pts_t;
205
206         /* the reason we have the servicereference as additional argument is
207            that we don't have to create one object for every entry in a possibly
208            large list, provided that no state information is nessesary to deliver
209            the required information. Anyway - ref *must* be the same as the argument
210            to the info() or getIServiceInformation call! */
211
212         /* About the usage of SWIG_VOID:
213            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
214            the "superflouus" RESULT return values.
215            
216            Python code has to check the returned pointer against 0. This works,
217            as all functions returning instances in smartpointers AND having a 
218            RESULT have to BOTH return non-zero AND set the pointer to zero.
219            
220            Python code thus can't check for the reason, but the reason isn't
221            user-servicable anyway. If you want to return a real reason which
222            goes beyong "it just doesn't work", use extra variables for this,
223            not the RESULT.
224            
225            Hide the result only if there is another way to check for failure! */
226            
227 class eServiceEvent;
228
229 SWIG_IGNORE(iStaticServiceInformation);
230 class iStaticServiceInformation: public iObject
231 {
232 #ifdef SWIG
233         iStaticServiceInformation();
234         ~iStaticServiceInformation();
235 #endif
236 public:
237         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
238
239                 // doesn't need to be implemented, should return -1 then.
240         virtual int getLength(const eServiceReference &ref);
241         virtual SWIG_VOID(RESULT) getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time=-1);
242                 // returns true when not implemented
243         virtual int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
244
245         virtual int getInfo(const eServiceReference &ref, int w);
246         virtual std::string getInfoString(const eServiceReference &ref,int w);
247         virtual PyObject *getInfoObject(const eServiceReference &ref, int w);
248
249         virtual int setInfo(const eServiceReference &ref, int w, int v);
250         virtual int setInfoString(const eServiceReference &ref, int w, const char *v);
251 };
252 SWIG_TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
253
254 class iServiceInformation_ENUMS
255 {
256 #ifdef SWIG
257         iServiceInformation_ENUMS();
258         ~iServiceInformation_ENUMS();
259 #endif
260 public:
261         enum {
262                 sIsCrypted,             /* is encrypted (no indication if decrypt was possible) */
263                 sAspect,                /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
264                 sIsMultichannel,        /* multichannel *available* (probably not selected) */
265
266                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
267                            that's also the reason why they are so globally defined.
268                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
269                            i will change this to return a user-readable text like "zero x zero three three" (and change the
270                            exact spelling in every version) to stop that! */
271
272                 sVideoPID,
273                 sAudioPID,
274                 sPCRPID,
275                 sPMTPID,
276                 sTXTPID,
277
278                 sSID,
279                 sONID,
280                 sTSID,
281                 sNamespace,
282                 sProvider,
283
284                 sDescription,
285                 sServiceref,
286                 sTimeCreate,            /* unix time or string */
287
288                 sTitle,
289                 sArtist,
290                 sAlbum,
291                 sComment,
292                 sTracknumber,
293                 sGenre,
294                 sCAIDs,
295                 sVideoType,             /* MPEG2 MPEG4 */
296
297                 sTags,                          /* space seperated list of tags */
298
299                 sDVBState,                      /* states as defined in pmt handler (as events there) */
300
301                 sVideoHeight,
302                 sVideoWidth,
303
304                 sTransponderData,       /* transponderdata as python dict */
305
306                 sUser = 0x100
307         };
308         enum {
309                 resNA = -1,
310                 resIsString = -2,
311                 resIsPyObject = -3
312         };
313 };
314
315 /* some words to structs like struct iServiceInformation_ENUMS
316 For some classes we need in python just the SmartPointer Variants.
317 So we prevent building wrapper classes for the non smart pointer classes with the SWIG_IGNORE makro.
318 But now we have the problem that swig do not export enums for smart pointer classes (i dont know why).
319 So we move all enum's to own classes (with _ENUMS as name ending) and let our real
320 class inherit from the *_ENUMS class. This *_ENUMS classes are normally exportet via swig to python.
321 But in the python code we doesn't like to write iServiceInformation_ENUMS.sVideoType....
322 we like to write iServiceInformation.sVideoType.
323 So until swig have no Solution for this Problem we call in lib/python/Makefile.am a python script named
324 enigma_py_patcher.py to remove the "_ENUMS" strings in enigma.py at all needed locations. */
325
326 SWIG_IGNORE(iServiceInformation);
327 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
328 {
329 #ifdef SWIG
330         iServiceInformation();
331         ~iServiceInformation();
332 #endif
333 public:
334         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
335         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
336
337         virtual int getInfo(int w);
338         virtual std::string getInfoString(int w);
339         virtual PyObject *getInfoObject(int w);
340
341         virtual int setInfo(int w, int v);
342         virtual int setInfoString(int w, const char *v);
343 };
344 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
345
346 class iFrontendInformation_ENUMS
347 {
348 #ifdef SWIG
349         iFrontendInformation_ENUMS();
350         ~iFrontendInformation_ENUMS();
351 #endif
352 public:
353         enum {
354                 bitErrorRate,
355                 signalPower,
356                 signalQuality,
357                 lockState,
358                 syncState,
359                 frontendNumber,
360                 signalQualitydB,
361         };
362 };
363
364 SWIG_IGNORE(iFrontendInformation);
365 class iFrontendInformation: public iFrontendInformation_ENUMS, public iObject
366 {
367 #ifdef SWIG
368         iFrontendInformation();
369         ~iFrontendInformation();
370 #endif
371 public:
372         virtual int getFrontendInfo(int w)=0;
373         virtual PyObject *getFrontendData()=0;
374         virtual PyObject *getFrontendStatus()=0;
375         virtual PyObject *getTransponderData(bool original)=0;
376         virtual PyObject *getAll(bool original)=0; // a sum of getFrontendData/Status/TransponderData
377 };
378 SWIG_TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
379
380 SWIG_IGNORE(iPauseableService);
381 class iPauseableService: public iObject
382 {
383 #ifdef SWIG
384         iPausableService();
385         ~iPausableService();
386 #endif
387 public:
388         virtual RESULT pause()=0;
389         virtual RESULT unpause()=0;
390
391                 /* hm. */
392         virtual RESULT setSlowMotion(int ratio=0)=0;
393         virtual RESULT setFastForward(int ratio=0)=0;
394 };
395 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
396
397 class iSeekableService_ENUMS
398 {
399 #ifdef SWIG
400         iSeekableService_ENUMS();
401         ~iSeekableService_ENUMS();
402 #endif
403 public:
404         enum { dirForward = +1, dirBackward = -1 };
405 };
406
407 SWIG_IGNORE(iSeekableService);
408 class iSeekableService: public iSeekableService_ENUMS, public iObject
409 {
410 #ifdef SWIG
411         iSeekableService();
412         ~iSeekableService();
413 #endif
414 public:
415         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
416         virtual RESULT seekTo(pts_t to)=0;
417         virtual RESULT seekRelative(int direction, pts_t to)=0;
418         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
419                 /* if you want to do several seeks in a row, you can enable the trickmode.
420                    audio will be switched off, sync will be disabled etc. */
421         virtual RESULT setTrickmode(int trick=0)=0;
422         virtual RESULT isCurrentlySeekable()=0;
423         virtual RESULT seekChapter(int chapter)=0;      
424 };
425 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
426
427 struct iAudioTrackInfo
428 {
429 #ifndef SWIG
430         std::string m_description;
431         std::string m_language; /* iso639 */
432         int m_pid; /* for association with the stream. */
433 #endif
434         std::string getDescription() { return m_description; }
435         std::string getLanguage() { return m_language; }
436         int getPID() { return m_pid; }
437 };
438 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
439
440 SWIG_IGNORE(iAudioTrackSelection);
441 class iAudioTrackSelection: public iObject
442 {
443 #ifdef SWIG
444         iAudioTrackSelection();
445         ~iAudioTrackSelection();
446 #endif
447 public:
448         virtual int getNumberOfTracks()=0;
449         virtual RESULT selectTrack(unsigned int i)=0;
450         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
451         virtual int getCurrentTrack()=0;
452 };
453 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
454
455 class iAudioChannelSelection_ENUMS
456 {
457 #ifdef SWIG
458         iAudioChannelSelection_ENUMS();
459         ~iAudioChannelSelection_ENUMS();
460 #endif
461 public:
462         enum { LEFT, STEREO, RIGHT };
463 };
464
465 SWIG_IGNORE(iAudioChannelSelection);
466 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
467 {
468 #ifdef SWIG
469         iAudioChannelSelection();
470         ~iAudioChannelSelection();
471 #endif
472 public:
473         virtual int getCurrentChannel()=0;
474         virtual RESULT selectChannel(int i)=0;
475 };
476 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
477
478 SWIG_IGNORE(iAudioDelay);
479 class iAudioDelay: public iObject
480 {
481 #ifdef SWIG
482         iAudioDelay();
483         ~iAudioDelay();
484 #endif
485 public:
486         virtual int getAC3Delay()=0;
487         virtual int getPCMDelay()=0;
488         virtual void setAC3Delay(int)=0;
489         virtual void setPCMDelay(int)=0;
490 };
491 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
492
493 class iRdsDecoder_ENUMS
494 {
495 #ifdef SWIG
496         iRdsDecoder_ENUMS();
497         ~iRdsDecoder_ENUMS();
498 #endif
499 public:
500         enum { RadioText, RtpText };
501 };
502
503 SWIG_IGNORE(iRdsDecoder);
504 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
505 {
506 #ifdef SWIG
507         iRdsDecoder();
508         ~iRdsDecoder();
509 #endif
510 public:
511         virtual std::string getText(int x=RadioText)=0;
512         virtual void showRassSlidePicture()=0;
513         virtual void showRassInteractivePic(int page, int subpage)=0;
514         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
515 };
516 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
517
518 SWIG_IGNORE(iSubserviceList);
519 class iSubserviceList: public iObject
520 {
521 #ifdef SWIG
522         iSubserviceList();
523         ~iSubserviceList();
524 #endif
525 public:
526         virtual int getNumberOfSubservices()=0;
527         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
528 };
529 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
530
531 SWIG_IGNORE(iTimeshiftService);
532 class iTimeshiftService: public iObject
533 {
534 #ifdef SWIG
535         iTimeshiftService();
536         ~iTimeshiftService();
537 #endif
538 public:
539         virtual RESULT startTimeshift()=0;
540         virtual RESULT stopTimeshift()=0;
541
542         virtual int isTimeshiftActive()=0;
543                         /* this essentially seeks to the relative end of the timeshift buffer */
544         virtual RESULT activateTimeshift()=0;
545 };
546 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
547
548         /* not related to eCueSheet */
549
550 class iCueSheet_ENUMS
551 {
552 #ifdef SWIG
553         iCueSheet_ENUMS();
554         ~iCueSheet_ENUMS();
555 #endif
556 public:
557         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
558 };
559
560 SWIG_IGNORE(iCueSheet);
561 class iCueSheet: public iCueSheet_ENUMS, public iObject
562 {
563 #ifdef SWIG
564         iCueSheet();
565         ~iCueSheet();
566 #endif
567 public:
568         /* returns a list of (pts, what)-tuples */
569         virtual PyObject *getCutList() = 0;
570         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
571         virtual void setCutListEnable(int enable) = 0;
572 };
573 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
574
575 class eWidget;
576 class PyList;
577
578 SWIG_IGNORE(iSubtitleOutput);
579 class iSubtitleOutput: public iObject
580 {
581 public:
582         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
583         virtual RESULT disableSubtitles(eWidget *parent)=0;
584         virtual PyObject *getSubtitleList()=0;
585         virtual PyObject *getCachedSubtitle()=0;
586 };
587 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
588
589 SWIG_IGNORE(iMutableServiceList);
590 class iMutableServiceList: public iObject
591 {
592 #ifdef SWIG
593         iMutableServiceList();
594         ~iMutableServiceList();
595 #endif
596 public:
597                 /* flush changes */
598         virtual RESULT flushChanges()=0;
599                 /* adds a service to a list */
600         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
601                 /* removes a service from a list */
602         virtual RESULT removeService(eServiceReference &ref)=0;
603                 /* moves a service in a list, only if list suppports a specific sort method. */
604                 /* pos is the new, absolute position from 0..size-1 */
605         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
606                 /* set name of list, for bouquets this is the visible bouquet name */
607         virtual RESULT setListName(const std::string &name)=0;
608 };
609 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
610
611 SWIG_IGNORE(iListableService);
612 class iListableService: public iObject
613 {
614 #ifdef SWIG
615         iListableService();
616         ~iListableService();
617 #endif
618 public:
619 #ifndef SWIG
620                 /* legacy interface: get a list */
621         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
622 #endif
623         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
624
625                 /* new, shiny interface: streaming. */
626         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
627
628                 /* use this for sorting. output is not sorted because of either
629                  - performance reasons: the whole list must be buffered or
630                  - the interface would be restricted to a list. streaming
631                    (as well as a future "active" extension) won't be possible.
632                 */
633         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
634
635         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
636 };
637 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
638
639 #ifndef SWIG
640         /* a helper class which can be used as argument to stl's sort(). */
641 class iListableServiceCompare
642 {
643         ePtr<iListableService> m_list;
644 public:
645         iListableServiceCompare(iListableService *list): m_list(list) { }
646         bool operator()(const eServiceReference &a, const eServiceReference &b)
647         {
648                 return m_list->compareLessEqual(a, b);
649         }
650 };
651 #endif
652
653 SWIG_IGNORE(iServiceOfflineOperations);
654 class iServiceOfflineOperations: public iObject
655 {
656 #ifdef SWIG
657         iServiceOfflineOperations();
658         ~iServiceOfflineOperations();
659 #endif
660 public:
661                 /* to delete a service, forever. */
662         virtual RESULT deleteFromDisk(int simulate=1)=0;
663
664                 /* for transferring a service... */
665         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
666
667                 // TODO: additional stuff, like a conversion interface?
668 };
669 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
670
671 SWIG_IGNORE(iStreamableService);
672 class iStreamableService: public iObject
673 {
674 #ifdef SWIG
675         iStreamableService();
676         ~iStreamableService();
677 #endif
678 public:
679                 /* returns a dict:
680                         { "demux": <n>,
681                           "pids": [(x,type),(y,type),(z,type),..],
682                           ...
683                         }
684                         with type being "video", "audio", "pmt", "pat"...
685                 */
686         virtual PyObject *getStreamingData()=0;
687 };
688 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
689
690 class iServiceKeys_ENUMS
691 {
692 #ifdef SWIG
693         iServiceKeys_ENUMS();
694         ~iServiceKeys_ENUMS();
695 #endif
696 public:
697         enum {
698                 keyLeft,
699                 keyRight,
700                 keyUp,
701                 keyDown,
702                 keyOk,
703                 keyUser = 0x100
704         };
705 };
706
707 SWIG_IGNORE(iServiceKeys);
708 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
709 {
710 #ifdef SWIG
711         iServiceKeys();
712         ~iServiceKeys();
713 #endif
714 public:
715         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
716 };
717 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
718
719 class iPlayableService_ENUMS
720 {
721 #ifdef SWIG
722         iPlayableService_ENUMS();
723         ~iPlayableService_ENUMS();
724 #endif
725 public:
726         enum {
727                         /* these first two events are magical, and should only
728                            be generated if you know what you're doing. */
729                 evStart,
730                 evEnd,
731
732                 evTuneFailed,
733
734                         /* when iServiceInformation is implemented:*/
735                 evUpdatedEventInfo,
736                 evUpdatedInfo,
737
738                         /* when seek() is implemented: */
739                 evSeekableStatusChanged, /* for example when timeshifting */
740
741                 evEOF,
742                 evSOF, /* bounced against start of file (when seeking backwards) */
743
744                         /* when cueSheet is implemented */
745                 evCuesheetChanged,
746
747                         /* when rdsDecoder is implemented */
748                 evUpdatedRadioText,
749                 evUpdatedRtpText,
750
751                         /* Radio Screenshow Support */
752                 evUpdatedRassSlidePic,
753                 evUpdatedRassInteractivePicMask,
754
755                 evVideoSizeChanged,
756
757                 evStopped,
758
759                 evUser = 0x100
760         };
761 };
762
763 SWIG_IGNORE(iPlayableService);
764 class iPlayableService: public iPlayableService_ENUMS, public iObject
765 {
766 #ifdef SWIG
767         iPlayableService();
768         ~iPlaybleService();
769 #endif
770         friend class iServiceHandler;
771 public:
772 #ifndef SWIG
773         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
774 #endif
775         virtual RESULT start()=0;
776         virtual RESULT stop()=0;
777                         /* might have to be changed... */
778         virtual RESULT setTarget(int target)=0;
779         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
780         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
781         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
782         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
783         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
784         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
785         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
786         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
787         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
788         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
789         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
790         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
791         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
792         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
793 };
794 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
795
796 class iRecordableService_ENUMS
797 {
798 #ifdef SWIG
799         iRecordableService_ENUMS();
800         ~iRecordableService_ENUMS();
801 #endif
802 public:
803         enum {
804                 evStart,
805                 evEnd,
806                 evTunedIn,
807                 evTuneFailed,
808                 evRecordRunning,
809                 evRecordStopped,
810                 evNewProgramInfo,
811                 evRecordFailed,
812                 evRecordWriteError
813         };
814         enum {
815                 NoError=0,
816                 errOpenRecordFile=-1,
817                 errNoDemuxAvailable=-2,
818                 errNoTsRecorderAvailable=-3,
819                 errDiskFull=-4,
820                 errTuneFailed=-255,
821                 errMisconfiguration = -256,
822                 errNoResources = -257,
823         };
824 };
825
826 SWIG_IGNORE(iRecordableService);
827 class iRecordableService: public iRecordableService_ENUMS, public iObject
828 {
829 #ifdef SWIG
830         iRecordableService();
831         ~iRecordableService();
832 #endif
833 public:
834 #ifndef SWIG
835         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
836 #endif
837         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
838         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
839         virtual RESULT prepareStreaming()=0;
840         virtual RESULT start()=0;
841         virtual RESULT stop()=0;
842         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
843         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
844 };
845 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
846
847 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
848
849 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
850 {
851         return New_iRecordableServicePtr(c);
852 }
853
854 #ifndef SWIG
855 #ifdef PYTHON_REFCOUNT_DEBUG
856 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
857 {
858         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
859 }
860 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
861 #else
862 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
863 {
864         return New_iRecordableServicePtr(ptr);
865 }
866 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
867 #endif
868 #endif // SWIG
869
870 SWIG_IGNORE(iServiceHandler);
871 class iServiceHandler: public iObject
872 {
873 #ifdef SWIG
874         iServiceHandler();
875         ~iServiceHandler();
876 #endif
877 public:
878         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
879         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
880         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
881         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
882         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
883 };
884 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
885
886 #endif