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