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