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