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