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