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