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