4.2.3r1
[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         virtual RESULT setPrevPlaybackFile(const char *fn)=0; // not needed by our internal timeshift.. but external plugin...
614
615         virtual int isTimeshiftActive()=0;
616                         /* this essentially seeks to the relative end of the timeshift buffer */
617         virtual RESULT activateTimeshift()=0;
618 };
619 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
620
621         /* not related to eCueSheet */
622
623 class iCueSheet_ENUMS
624 {
625 #ifdef SWIG
626         iCueSheet_ENUMS();
627         ~iCueSheet_ENUMS();
628 #endif
629 public:
630         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
631 };
632
633 SWIG_IGNORE_ENUMS(iCueSheet);
634 class iCueSheet: public iCueSheet_ENUMS, public iObject
635 {
636 #ifdef SWIG
637         iCueSheet();
638         ~iCueSheet();
639 #endif
640 public:
641         /* returns a list of (pts, what)-tuples */
642         virtual std::list<std::pair<pts_t, unsigned int> > getCutList() = 0;
643         virtual void setCutList(std::list<std::pair<pts_t, unsigned int> > list) = 0;
644         virtual void setCutListEnable(int enable) = 0;
645 };
646 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
647
648 class eWidget;
649 class PyList;
650
651 SWIG_IGNORE(iSubtitleOutput);
652 class iSubtitleOutput: public iObject
653 {
654 public:
655         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
656         virtual RESULT disableSubtitles(eWidget *parent)=0;
657         virtual PyObject *getSubtitleList()=0;
658         virtual PyObject *getCachedSubtitle()=0;
659 };
660 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
661
662 SWIG_IGNORE(iMutableServiceList);
663 class iMutableServiceList: public iObject
664 {
665 #ifdef SWIG
666         iMutableServiceList();
667         ~iMutableServiceList();
668 #endif
669 public:
670                 /* flush changes */
671         virtual RESULT flushChanges()=0;
672                 /* adds a service to a list */
673         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
674                 /* removes a service from a list */
675         virtual RESULT removeService(eServiceReference &ref)=0;
676                 /* moves a service in a list, only if list suppports a specific sort method. */
677                 /* pos is the new, absolute position from 0..size-1 */
678         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
679                 /* set name of list, for bouquets this is the visible bouquet name */
680         virtual RESULT setListName(const std::string &name)=0;
681 };
682 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
683
684 SWIG_IGNORE(iListableService);
685 class iListableService: public iObject
686 {
687 #ifdef SWIG
688         iListableService();
689         ~iListableService();
690 #endif
691 public:
692 #ifndef SWIG
693                 /* legacy interface: get a list */
694         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
695 #endif
696         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
697
698                 /* new, shiny interface: streaming. */
699         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
700
701                 /* use this for sorting. output is not sorted because of either
702                  - performance reasons: the whole list must be buffered or
703                  - the interface would be restricted to a list. streaming
704                    (as well as a future "active" extension) won't be possible.
705                 */
706         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
707
708         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
709 };
710 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
711
712 #ifndef SWIG
713         /* a helper class which can be used as argument to stl's sort(). */
714 class iListableServiceCompare
715 {
716         ePtr<iListableService> m_list;
717 public:
718         iListableServiceCompare(iListableService *list): m_list(list) { }
719         bool operator()(const eServiceReference &a, const eServiceReference &b)
720         {
721                 return m_list->compareLessEqual(a, b);
722         }
723 };
724 #endif
725
726 SWIG_IGNORE(iServiceOfflineOperations);
727 class iServiceOfflineOperations: public iObject
728 {
729 #ifdef SWIG
730         iServiceOfflineOperations();
731         ~iServiceOfflineOperations();
732 #endif
733 public:
734                 /* to delete a service, forever. */
735         virtual RESULT deleteFromDisk(int simulate=1)=0;
736
737                 /* for transferring a service... */
738         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
739         
740                 /* a blocking call to reindex a file */
741         virtual int reindex() = 0;
742
743                 // TODO: additional stuff, like a conversion interface?
744 };
745 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
746
747 SWIG_IGNORE(iStreamableService);
748 class iStreamableService: public iObject
749 {
750 #ifdef SWIG
751         iStreamableService();
752         ~iStreamableService();
753 #endif
754 public:
755                 /* returns a dict:
756                         { "demux": <n>,
757                           "pids": [(x,type),(y,type),(z,type),..],
758                           ...
759                         }
760                         with type being "video", "audio", "pmt", "pat"...
761                 */
762         virtual std::map<std::string, boost::any> getStreamingData(bool includeEit=true)=0;
763 };
764 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
765
766 SWIG_IGNORE(iStreamedService);
767 class iStreamedService: public iObject
768 {
769 #ifdef SWIG
770         iStreamedService();
771         ~iStreamedService();
772 #endif
773 public:
774         virtual std::list<int> getBufferCharge() const=0;
775         virtual int setBufferSize(int size)=0;
776 };
777 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamedService>, iStreamedServicePtr);
778
779 class iServiceKeys_ENUMS
780 {
781 #ifdef SWIG
782         iServiceKeys_ENUMS();
783         ~iServiceKeys_ENUMS();
784 #endif
785 public:
786         enum {
787                 keyLeft,
788                 keyRight,
789                 keyUp,
790                 keyDown,
791                 keyOk,
792                 keyUser = 0x100
793         };
794 };
795
796 SWIG_IGNORE_ENUMS(iServiceKeys);
797 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
798 {
799 #ifdef SWIG
800         iServiceKeys();
801         ~iServiceKeys();
802 #endif
803 public:
804         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
805 };
806 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
807
808 class eDVBServiceAITHandler;
809
810 SWIG_IGNORE(iHbbtv);
811 class iHbbtv: public iObject
812 {
813 #ifdef SWIG
814         iHbbtv();
815         ~iHbbtv();
816 #endif
817 public:
818 #ifndef SWIG
819         virtual eDVBServiceAITHandler *getAitHandler(void)=0;
820 #endif
821 };
822 SWIG_TEMPLATE_TYPEDEF(ePtr<iHbbtv>, iHbbtvPtr);
823
824 class iPlayableService_ENUMS
825 {
826 #ifdef SWIG
827         iPlayableService_ENUMS();
828         ~iPlayableService_ENUMS();
829 #endif
830 public:
831         enum {
832                         /* these first two events are magical, and should only
833                            be generated if you know what you're doing. */
834                 evStart,
835                 evEnd,
836
837                 evTunedIn,
838                 evTuneFailed,
839
840                         /* when iServiceInformation is implemented:*/
841                 evUpdatedEventInfo,
842                 evUpdatedInfo,
843
844                         /* when seek() is implemented: */
845                 evSeekableStatusChanged, /* for example when timeshifting */
846
847                 evEOF,
848                 evSOF, /* bounced against start of file (when seeking backwards) */
849
850                         /* when cueSheet is implemented */
851                 evCuesheetChanged,
852
853                         /* when rdsDecoder is implemented */
854                 evUpdatedRadioText,
855                 evUpdatedRtpText,
856
857                         /* Radio Screenshow Support */
858                 evUpdatedRassSlidePic,
859                 evUpdatedRassInteractivePicMask,
860
861                 evVideoSizeChanged,
862                 evVideoFramerateChanged,
863                 evVideoProgressiveChanged,
864
865                 evBuffering,
866
867                 evStopped,
868
869                 evUser = 0x100
870         };
871 };
872
873 SWIG_IGNORE_ENUMS(iPlayableService);
874 class iPlayableService: public iPlayableService_ENUMS, public iObject
875 {
876 #ifdef SWIG
877         iPlayableService();
878         ~iPlaybleService();
879 #endif
880         friend class iServiceHandler;
881 public:
882 #ifndef SWIG
883         virtual RESULT connectEvent(const sigc::slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
884 #endif
885         virtual RESULT start()=0;
886         virtual RESULT stop()=0;
887                         /* might have to be changed... */
888         virtual RESULT setTarget(int target)=0;
889         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
890         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
891         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
892         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
893         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
894         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
895         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
896         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
897         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
898         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
899         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
900         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
901         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
902         virtual SWIG_VOID(RESULT) streamed(ePtr<iStreamedService> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
903         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
904         virtual SWIG_VOID(RESULT) hbbtv(ePtr<iHbbtv> &SWIG_NAMED_OUTPUT(ptr)) { ptr = 0; return -1; }
905 };
906 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
907
908 class iRecordableService_ENUMS
909 {
910 #ifdef SWIG
911         iRecordableService_ENUMS();
912         ~iRecordableService_ENUMS();
913 #endif
914 public:
915         enum {
916                 evStart,
917                 evEnd,
918                 evTunedIn,
919                 evTuneFailed,
920                 evRecordRunning,
921                 evRecordStopped,
922                 evNewProgramInfo,
923                 evRecordFailed,
924                 evRecordWriteError,
925                 evNewEventInfo
926         };
927         enum {
928                 NoError=0,
929                 errOpenRecordFile=-1,
930                 errNoDemuxAvailable=-2,
931                 errNoTsRecorderAvailable=-3,
932                 errDiskFull=-4,
933                 errTuneFailed=-255,
934                 errMisconfiguration = -256,
935                 errNoResources = -257,
936         };
937 };
938
939 SWIG_IGNORE_ENUMS(iRecordableService);
940 class iRecordableService: public iRecordableService_ENUMS, public iObject
941 {
942 #ifdef SWIG
943         iRecordableService();
944         ~iRecordableService();
945 #endif
946 public:
947 #ifndef SWIG
948         virtual RESULT connectEvent(const sigc::slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
949 #endif
950         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
951         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;
952         virtual RESULT prepareStreaming()=0;
953         virtual RESULT start(bool simulate=false)=0;
954         virtual RESULT stop()=0;
955         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
956         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
957         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
958 };
959 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
960
961 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
962
963 #ifndef SWIG
964 #ifdef PYTHON_REFCOUNT_DEBUG
965 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
966 {
967         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
968 }
969 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
970 #else
971 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
972 {
973         return New_iRecordableServicePtr(ptr);
974 }
975 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
976 #endif
977 #endif // SWIG
978
979 SWIG_IGNORE(iServiceHandler);
980 class iServiceHandler: public iObject
981 {
982 #ifdef SWIG
983         iServiceHandler();
984         ~iServiceHandler();
985 #endif
986 public:
987         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
988         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
989         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
990         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
991         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
992 };
993 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
994
995 #endif