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