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