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