0983175f61a04936e0a980b411205387c174b55b
[openblackhole/openblackhole-enigma2.git] / 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 <connection.h>
9 #include <list>
10 #include <vector>
11
12 class eServiceEvent;
13
14 class eServiceReference
15 {
16 public:
17         enum
18         {
19                 idInvalid=-1,
20                 idStructure,    // service_id == 0 is root
21                 idDVB,
22                 idFile,
23                 idUser=0x1000,
24                 idServiceMP3=0x1001
25         };
26         int type;
27
28         enum
29         {
30                 isDirectory=1,          // SHOULD enter  (implies mustDescent)
31                 mustDescent=2,          // cannot be played directly - often used with "isDirectory" (implies canDescent)
32                 /*
33                         for example:
34                                 normal services have none of them - they can be fed directly into the "play"-handler.
35                                 normal directories have both of them set - you cannot play a directory directly and the UI should descent into it.
36                                 playlists have "mustDescent", but not "isDirectory" - you don't want the user to browse inside the playlist (unless he really wants)
37                                 services with sub-services have none of them, instead the have the "canDecsent" flag (as all of the above)
38                 */
39                 canDescent=4,                   // supports enterDirectory/leaveDirectory
40                 flagDirectory=isDirectory|mustDescent|canDescent,
41                 shouldSort=8,                   // should be ASCII-sorted according to service_name. great for directories.
42                 hasSortKey=16,          // has a sort key in data[3]. not having a sort key implies 0.
43                 sort1=32,                                       // sort key is 1 instead of 0
44                 isMarker=64,                    // Marker
45                 isGroup=128,                    // is a group of services
46                 isNumberedMarker=256, //use together with isMarker, to force the marker to be numbered
47                 isInvisible=512 // use to make services or markers in a list invisable
48         };
49         int flags; // flags will NOT be compared.
50
51         inline int getSortKey() const { return (flags & hasSortKey) ? data[3] : ((flags & sort1) ? 1 : 0); }
52
53 #ifndef SWIG
54         int data[8];
55         std::string path;
56 #endif
57         std::string getPath() const { return path; }
58         void setPath( const std::string &n ) { path=n; }
59
60         unsigned int getUnsignedData(unsigned int num) const
61         {
62                 if ( num < sizeof(data)/sizeof(int) )
63                         return data[num];
64                 return 0;
65         }
66
67         int getData(unsigned int num) const
68         {
69                 if ( num < sizeof(data)/sizeof(int) )
70                         return data[num];
71                 return 0;
72         }
73
74         void setUnsignedData(unsigned int num, unsigned int val)
75         {
76                 if ( num < sizeof(data)/sizeof(int) )
77                         data[num] = val;
78         }
79
80         void setData(unsigned int num, int val)
81         {
82                 if ( num < sizeof(data)/sizeof(int) )
83                         data[num] = val;
84         }
85
86 // only for override service names in bouquets or to give servicerefs a name which not have a
87 // real existing service ( for dvb eServiceDVB )
88 #ifndef SWIG
89         std::string name;
90         int number;
91 #endif
92         std::string getName() const { return name; }
93         void setName( const std::string &n ) { name=n; }
94         int getChannelNum() const { return number; }
95         void setChannelNum(const int n) { number = n; }
96
97         eServiceReference()
98                 : type(idInvalid), flags(0)
99         {
100                 memset(data, 0, sizeof(data));
101                 number = 0;
102         }
103 #ifndef SWIG
104         eServiceReference(int type, int flags)
105                 : type(type), flags(flags)
106         {
107                 memset(data, 0, sizeof(data));
108                 number = 0;
109         }
110         eServiceReference(int type, int flags, int data0)
111                 : type(type), flags(flags)
112         {
113                 memset(data, 0, sizeof(data));
114                 data[0]=data0;
115                 number = 0;
116         }
117         eServiceReference(int type, int flags, int data0, int data1)
118                 : type(type), flags(flags)
119         {
120                 memset(data, 0, sizeof(data));
121                 data[0]=data0;
122                 data[1]=data1;
123                 number = 0;
124         }
125         eServiceReference(int type, int flags, int data0, int data1, int data2)
126                 : type(type), flags(flags)
127         {
128                 memset(data, 0, sizeof(data));
129                 data[0]=data0;
130                 data[1]=data1;
131                 data[2]=data2;
132                 number = 0;
133         }
134         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3)
135                 : type(type), flags(flags)
136         {
137                 memset(data, 0, sizeof(data));
138                 data[0]=data0;
139                 data[1]=data1;
140                 data[2]=data2;
141                 data[3]=data3;
142                 number = 0;
143         }
144         eServiceReference(int type, int flags, int data0, int data1, int data2, int data3, int data4)
145                 : type(type), flags(flags)
146         {
147                 memset(data, 0, sizeof(data));
148                 data[0]=data0;
149                 data[1]=data1;
150                 data[2]=data2;
151                 data[3]=data3;
152                 data[4]=data4;
153                 number = 0;
154         }
155         operator bool() const
156         {
157                 return valid();
158         }
159 #endif
160         eServiceReference(int type, int flags, const std::string &path)
161                 : type(type), flags(flags), path(path)
162         {
163                 memset(data, 0, sizeof(data));
164         }
165         eServiceReference(const std::string &string);
166         std::string toString() const;
167         std::string toCompareString() const;
168         bool operator==(const eServiceReference &c) const
169         {
170                 if (type != c.type)
171                         return 0;
172                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
173         }
174         bool operator!=(const eServiceReference &c) const
175         {
176                 return !(*this == c);
177         }
178         bool operator<(const eServiceReference &c) const
179         {
180                 if (type < c.type)
181                         return 1;
182
183                 if (type > c.type)
184                         return 0;
185
186                 int r=memcmp(data, c.data, sizeof(int)*8);
187                 if (r)
188                         return r < 0;
189                 return path < c.path;
190         }
191
192         int valid() const
193         {
194                 return type != idInvalid;
195         }
196 };
197
198 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
199
200 extern PyObject *New_eServiceReference(const eServiceReference &ref); // defined in enigma_python.i
201
202 #ifndef SWIG
203 #ifdef PYTHON_REFCOUNT_DEBUG
204 inline ePyObject Impl_New_eServiceReference(const char* file, int line, const eServiceReference &ref)
205 {
206         return ePyObject(New_eServiceReference(ref), file, line);
207 }
208 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(__FILE__, __LINE__, ref)
209 #else
210 inline ePyObject Impl_New_eServiceReference(const eServiceReference &ref)
211 {
212         return New_eServiceReference(ref);
213 }
214 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(ref)
215 #endif
216 #endif // SWIG
217
218 typedef long long pts_t;
219
220         /* the reason we have the servicereference as additional argument is
221            that we don't have to create one object for every entry in a possibly
222            large list, provided that no state information is nessesary to deliver
223            the required information. Anyway - ref *must* be the same as the argument
224            to the info() or getIServiceInformation call! */
225
226         /* About the usage of SWIG_VOID:
227            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
228            the "superflouus" RESULT return values.
229
230            Python code has to check the returned pointer against 0. This works,
231            as all functions returning instances in smartpointers AND having a
232            RESULT have to BOTH return non-zero AND set the pointer to zero.
233
234            Python code thus can't check for the reason, but the reason isn't
235            user-servicable anyway. If you want to return a real reason which
236            goes beyong "it just doesn't work", use extra variables for this,
237            not the RESULT.
238
239            Hide the result only if there is another way to check for failure! */
240
241 class eServiceEvent;
242 class iDVBTransponderData;
243
244 class iServiceInfoContainer: public iObject
245 {
246 public:
247         virtual int getInteger(unsigned int index) const { return 0; }
248         virtual std::string getString(unsigned int index) const { return ""; }
249         virtual double getDouble(unsigned int index) const { return 0.0; }
250         virtual unsigned char *getBuffer(unsigned int &size) const { return NULL; }
251 };
252
253 class iStaticServiceInformation: public iObject
254 {
255 #ifdef SWIG
256         iStaticServiceInformation();
257         ~iStaticServiceInformation();
258 #endif
259 public:
260         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
261
262                 // doesn't need to be implemented, should return -1 then.
263         virtual int getLength(const eServiceReference &ref);
264         virtual SWIG_VOID(RESULT) getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time=-1);
265                 // returns true when not implemented
266         virtual int isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate=false);
267
268         virtual int getInfo(const eServiceReference &ref, int w);
269         virtual std::string getInfoString(const eServiceReference &ref,int w);
270         virtual ePtr<iServiceInfoContainer> getInfoObject(int w);
271         virtual ePtr<iDVBTransponderData> getTransponderData(const eServiceReference &ref);
272         virtual long long getFileSize(const eServiceReference &ref);
273         virtual bool isCrypted();
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                 sServiceref,
314                 sTimeCreate,            /* unix time or string */
315                 sFileSize,
316
317                 sCAIDs,
318                 sCAIDPIDs,
319                 sVideoType,             /* MPEG2 MPEG4 */
320
321                 sTags,                          /* space seperated list of tags */
322
323                 sDVBState,                      /* states as defined in pmt handler (as events there) */
324
325                 sVideoHeight,
326                 sVideoWidth,
327
328                 sTransponderData,       /* transponderdata as python dict */
329
330                 sCurrentChapter,
331                 sCurrentTitle,
332                 sTotalChapters,
333                 sTotalTitles,
334
335                 sTagTitle,
336                 sTagTitleSortname,
337                 sTagArtist,
338                 sTagArtistSortname,
339                 sTagAlbum,
340                 sTagAlbumSortname,
341                 sTagComposer,
342                 sTagDate,
343                 sTagGenre,
344                 sTagComment,
345                 sTagExtendedComment,
346                 sTagTrackNumber,
347                 sTagTrackCount,
348                 sTagAlbumVolumeNumber,
349                 sTagAlbumVolumeCount,
350                 sTagLocation,
351                 sTagHomepage,
352                 sTagDescription,
353                 sTagVersion,
354                 sTagISRC,
355                 sTagOrganization,
356                 sTagCopyright,
357                 sTagCopyrightURI,
358                 sTagContact,
359                 sTagLicense,
360                 sTagLicenseURI,
361                 sTagPerformer,
362                 sTagCodec,
363                 sTagVideoCodec,
364                 sTagAudioCodec,
365                 sTagBitrate,
366                 sTagNominalBitrate,
367                 sTagMinimumBitrate,
368                 sTagMaximumBitrate,
369                 sTagSerial,
370                 sTagEncoder,
371                 sTagEncoderVersion,
372                 sTagTrackGain,
373                 sTagTrackPeak,
374                 sTagAlbumGain,
375                 sTagAlbumPeak,
376                 sTagReferenceLevel,
377                 sTagLanguageCode,
378                 sTagImage,
379                 sTagPreviewImage,
380                 sTagAttachment,
381                 sTagBeatsPerMinute,
382                 sTagKeywords,
383                 sTagCRC,
384                 sTagChannelMode,
385
386                 sTransferBPS,
387
388                 sHBBTVUrl,
389                 sLiveStreamDemuxId,
390                 sBuffer,
391
392                 sUser = 0x100
393         };
394         enum {
395                 resNA = -1,
396                 resIsString = -2,
397                 resIsPyObject = -3
398         };
399 };
400
401 /* some words to structs like struct iServiceInformation_ENUMS
402 For some classes we need in python just the SmartPointer Variants.
403 So we prevent building wrapper classes for the non smart pointer classes with the SWIG_IGNORE makro.
404 But now we have the problem that swig do not export enums for smart pointer classes (i dont know why).
405 So we move all enum's to own classes (with _ENUMS as name ending) and let our real
406 class inherit from the *_ENUMS class. This *_ENUMS classes are normally exportet via swig to python.
407 But in the python code we doesn't like to write iServiceInformation_ENUMS.sVideoType....
408 we like to write iServiceInformation.sVideoType.
409 So until swig have no Solution for this Problem we call in lib/python/Makefile.am a python script named
410 enigma_py_patcher.py to remove the "_ENUMS" strings in enigma.py at all needed locations. */
411
412 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
413 {
414 #ifdef SWIG
415         iServiceInformation();
416         ~iServiceInformation();
417 #endif
418 public:
419         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
420         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
421
422         virtual int getInfo(int w);
423         virtual std::string getInfoString(int w);
424         virtual ePtr<iServiceInfoContainer> getInfoObject(int w);
425         virtual ePtr<iDVBTransponderData> getTransponderData();
426         virtual void getAITApplications(std::map<int, std::string> &aitlist) {};
427         virtual void getCaIds(std::vector<int> &caids, std::vector<int> &ecmpids);
428         virtual long long getFileSize();
429
430         virtual int setInfo(int w, int v);
431         virtual int setInfoString(int w, const char *v);
432 };
433 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
434
435 class iFrontendInformation_ENUMS
436 {
437 #ifdef SWIG
438         iFrontendInformation_ENUMS();
439         ~iFrontendInformation_ENUMS();
440 #endif
441 public:
442         enum {
443                 bitErrorRate,
444                 signalPower,
445                 signalQuality,
446                 lockState,
447                 syncState,
448                 frontendNumber,
449                 signalQualitydB,
450                 frontendStatus,
451                 snrValue,
452                 frequency,
453         };
454 };
455
456 class iDVBFrontendData;
457 class iDVBFrontendStatus;
458 class iDVBTransponderData;
459
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 ePtr<iDVBFrontendData> getFrontendData()=0;
469         virtual ePtr<iDVBFrontendStatus> getFrontendStatus()=0;
470         virtual ePtr<iDVBTransponderData> getTransponderData(bool original)=0;
471         void getAll() {}
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(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 struct iAudioTrackInfo
526 {
527 #ifndef SWIG
528         std::string m_description;
529         std::string m_language; /* iso639 */
530         int m_pid; /* for association with the stream. */
531 #endif
532         std::string getDescription() { return m_description; }
533         std::string getLanguage() { return m_language; }
534         int getPID() { return m_pid; }
535 };
536 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
537
538 SWIG_IGNORE(iAudioTrackSelection);
539 class iAudioTrackSelection: public iObject
540 {
541 #ifdef SWIG
542         iAudioTrackSelection();
543         ~iAudioTrackSelection();
544 #endif
545 public:
546         virtual int getNumberOfTracks()=0;
547         virtual RESULT selectTrack(unsigned int i)=0;
548         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
549         virtual int getCurrentTrack()=0;
550 };
551 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
552
553 class iAudioChannelSelection_ENUMS
554 {
555 #ifdef SWIG
556         iAudioChannelSelection_ENUMS();
557         ~iAudioChannelSelection_ENUMS();
558 #endif
559 public:
560         enum { LEFT, STEREO, RIGHT };
561 };
562
563 SWIG_IGNORE(iAudioChannelSelection);
564 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
565 {
566 #ifdef SWIG
567         iAudioChannelSelection();
568         ~iAudioChannelSelection();
569 #endif
570 public:
571         virtual int getCurrentChannel()=0;
572         virtual RESULT selectChannel(int i)=0;
573 };
574 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
575
576 SWIG_IGNORE(iAudioDelay);
577 class iAudioDelay: public iObject
578 {
579 #ifdef SWIG
580         iAudioDelay();
581         ~iAudioDelay();
582 #endif
583 public:
584         virtual int getAC3Delay()=0;
585         virtual int getPCMDelay()=0;
586         virtual void setAC3Delay(int)=0;
587         virtual void setPCMDelay(int)=0;
588 };
589 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
590
591 class iRdsDecoder_ENUMS
592 {
593 #ifdef SWIG
594         iRdsDecoder_ENUMS();
595         ~iRdsDecoder_ENUMS();
596 #endif
597 public:
598         enum { RadioText, RtpText };
599 };
600
601 SWIG_IGNORE(iRdsDecoder);
602 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
603 {
604 #ifdef SWIG
605         iRdsDecoder();
606         ~iRdsDecoder();
607 #endif
608 public:
609         virtual std::string getText(int x=RadioText)=0;
610         virtual void showRassSlidePicture()=0;
611         virtual void showRassInteractivePic(int page, int subpage)=0;
612         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
613 };
614 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
615
616 SWIG_IGNORE(iSubserviceList);
617 class iSubserviceList: public iObject
618 {
619 #ifdef SWIG
620         iSubserviceList();
621         ~iSubserviceList();
622 #endif
623 public:
624         virtual int getNumberOfSubservices()=0;
625         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
626 };
627 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
628
629 SWIG_IGNORE(iTimeshiftService);
630 class iTimeshiftService: public iObject
631 {
632 #ifdef SWIG
633         iTimeshiftService();
634         ~iTimeshiftService();
635 #endif
636 public:
637         virtual RESULT startTimeshift()=0;
638         virtual RESULT stopTimeshift(bool swToLive=true)=0;
639         virtual RESULT setNextPlaybackFile(const char *fn)=0; // not needed by our internal timeshift.. but external plugin...
640
641         virtual int isTimeshiftActive()=0;
642         virtual int isTimeshiftEnabled()=0;
643                         /* this essentially seeks to the relative end of the timeshift buffer */
644         virtual RESULT activateTimeshift()=0;
645         virtual RESULT saveTimeshiftFile()=0;
646         virtual std::string getTimeshiftFilename()=0;
647         virtual void switchToLive()=0;
648 };
649 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
650
651         /* not related to eCueSheet */
652
653 class iCueSheet_ENUMS
654 {
655 #ifdef SWIG
656         iCueSheet_ENUMS();
657         ~iCueSheet_ENUMS();
658 #endif
659 public:
660         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
661 };
662
663 SWIG_IGNORE(iCueSheet);
664 class iCueSheet: public iCueSheet_ENUMS, public iObject
665 {
666 #ifdef SWIG
667         iCueSheet();
668         ~iCueSheet();
669 #endif
670 public:
671         /* returns a list of (pts, what)-tuples */
672         virtual PyObject *getCutList() = 0;
673         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
674         virtual void setCutListEnable(int enable) = 0;
675 };
676 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
677
678 class PyList;
679
680 class eDVBTeletextSubtitlePage;
681 class eDVBSubtitlePage;
682 struct ePangoSubtitlePage;
683 class eRect;
684 struct gRegion;
685 struct gPixmap;
686
687 SWIG_IGNORE(iSubtitleUser);
688 class iSubtitleUser
689 {
690 public:
691         virtual void setPage(const eDVBTeletextSubtitlePage &p) = 0;
692         virtual void setPage(const eDVBSubtitlePage &p) = 0;
693         virtual void setPage(const ePangoSubtitlePage &p) = 0;
694         virtual void setPixmap(ePtr<gPixmap> &pixmap, gRegion changed, eRect dest) = 0;
695         virtual void destroy() = 0;
696 };
697
698 class iSubtitleOutput: public iObject
699 {
700 public:
701         struct SubtitleTrack
702         {
703                 int type;
704                 int pid;
705                 int page_number;
706                 int magazine_number;
707                 std::string language_code;
708         };
709
710         virtual RESULT enableSubtitles(iSubtitleUser *user, SubtitleTrack &track) = 0;
711         virtual RESULT disableSubtitles() = 0;
712         virtual RESULT getCachedSubtitle(SubtitleTrack &track) = 0;
713         virtual RESULT getSubtitleList(std::vector<SubtitleTrack> &subtitlelist) = 0;
714 };
715 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
716
717 SWIG_IGNORE(iMutableServiceList);
718 class iMutableServiceList: public iObject
719 {
720 #ifdef SWIG
721         iMutableServiceList();
722         ~iMutableServiceList();
723 #endif
724 public:
725                 /* flush changes */
726         virtual RESULT flushChanges()=0;
727                 /* adds a service to a list */
728         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
729                 /* removes a service from a list */
730         virtual RESULT removeService(eServiceReference &ref, bool renameBouquet=true)=0;
731                 /* moves a service in a list, only if list suppports a specific sort method. */
732                 /* pos is the new, absolute position from 0..size-1 */
733         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
734                 /* set name of list, for bouquets this is the visible bouquet name */
735         virtual RESULT setListName(const std::string &name)=0;
736 };
737 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
738
739 SWIG_IGNORE(iListableService);
740 class iListableService: public iObject
741 {
742 #ifdef SWIG
743         iListableService();
744         ~iListableService();
745 #endif
746 public:
747 #ifndef SWIG
748                 /* legacy interface: get a list */
749         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
750 #endif
751         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
752
753                 /* new, shiny interface: streaming. */
754         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
755
756                 /* use this for sorting. output is not sorted because of either
757                  - performance reasons: the whole list must be buffered or
758                  - the interface would be restricted to a list. streaming
759                    (as well as a future "active" extension) won't be possible.
760                 */
761         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
762
763         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
764 };
765 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
766
767 #ifndef SWIG
768         /* a helper class which can be used as argument to stl's sort(). */
769 class iListableServiceCompare
770 {
771         ePtr<iListableService> m_list;
772 public:
773         iListableServiceCompare(iListableService *list): m_list(list) { }
774         bool operator()(const eServiceReference &a, const eServiceReference &b)
775         {
776                 return m_list->compareLessEqual(a, b);
777         }
778 };
779 #endif
780
781 SWIG_IGNORE(iServiceOfflineOperations);
782 class iServiceOfflineOperations: public iObject
783 {
784 #ifdef SWIG
785         iServiceOfflineOperations();
786         ~iServiceOfflineOperations();
787 #endif
788 public:
789                 /* to delete a service, forever. */
790         virtual RESULT deleteFromDisk(int simulate=1)=0;
791
792                 /* for transferring a service... */
793         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
794
795                 /* a blocking call to reindex a file */
796         virtual int reindex() = 0;
797
798                 // TODO: additional stuff, like a conversion interface?
799 };
800 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
801
802 class iStreamData: public iObject
803 {
804 public:
805         virtual SWIG_VOID(RESULT) getAllPids(std::vector<int> &result) const = 0;
806         virtual SWIG_VOID(RESULT) getVideoPids(std::vector<int> &result) const = 0;
807         virtual SWIG_VOID(RESULT) getAudioPids(std::vector<int> &result) const = 0;
808         virtual SWIG_VOID(RESULT) getSubtitlePids(std::vector<int> &result) const = 0;
809         virtual SWIG_VOID(RESULT) getPmtPid(int &result) const = 0;
810         virtual SWIG_VOID(RESULT) getPatPid(int &result) const = 0;
811         virtual SWIG_VOID(RESULT) getPcrPid(int &result) const = 0;
812         virtual SWIG_VOID(RESULT) getTxtPid(int &result) const = 0;
813         virtual SWIG_VOID(RESULT) getServiceId(int &result) const = 0;
814         virtual SWIG_VOID(RESULT) getAdapterId(int &result) const = 0;
815         virtual SWIG_VOID(RESULT) getDemuxId(int &result) const = 0;
816         virtual SWIG_VOID(RESULT) getCaIds(std::vector<int> &caids, std::vector<int> &ecmpids) const = 0;
817 };
818
819 class iStreamableService: public iObject
820 {
821 #ifdef SWIG
822         iStreamableService();
823         ~iStreamableService();
824 #endif
825 public:
826         virtual ePtr<iStreamData> getStreamingData() = 0;
827 };
828 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
829
830 class iStreamBufferInfo: public iObject
831 {
832 public:
833         virtual int getBufferPercentage() const = 0;
834         virtual int getAverageInputRate() const = 0;
835         virtual int getAverageOutputRate() const = 0;
836         virtual int getBufferSpace() const = 0;
837         virtual int getBufferSize() const = 0;
838 };
839
840 class iStreamedService: public iObject
841 {
842 #ifdef SWIG
843         iStreamedService();
844         ~iStreamedService();
845 #endif
846 public:
847         virtual ePtr<iStreamBufferInfo> getBufferCharge()=0;
848         virtual int setBufferSize(int size)=0;
849 };
850 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamedService>, iStreamedServicePtr);
851
852 class iServiceKeys_ENUMS
853 {
854 #ifdef SWIG
855         iServiceKeys_ENUMS();
856         ~iServiceKeys_ENUMS();
857 #endif
858 public:
859         enum {
860                 keyLeft,
861                 keyRight,
862                 keyUp,
863                 keyDown,
864                 keyOk,
865                 keyUser = 0x100
866         };
867 };
868
869 SWIG_IGNORE(iServiceKeys);
870 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
871 {
872 #ifdef SWIG
873         iServiceKeys();
874         ~iServiceKeys();
875 #endif
876 public:
877         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
878 };
879 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
880
881 class iPlayableService_ENUMS
882 {
883 #ifdef SWIG
884         iPlayableService_ENUMS();
885         ~iPlayableService_ENUMS();
886 #endif
887 public:
888         enum {
889                         /* these first two events are magical, and should only
890                            be generated if you know what you're doing. */
891                 evStart,
892                 evEnd,
893
894                 evTunedIn,
895                 evTuneFailed,
896
897                         /* when iServiceInformation is implemented:*/
898                 evUpdatedEventInfo,
899                 evUpdatedInfo,
900                 evNewProgramInfo,
901
902                         /* when seek() is implemented: */
903                 evSeekableStatusChanged, /* for example when timeshifting */
904
905                 evEOF,
906                 evSOF, /* bounced against start of file (when seeking backwards) */
907
908                         /* when cueSheet is implemented */
909                 evCuesheetChanged,
910
911                         /* when rdsDecoder is implemented */
912                 evUpdatedRadioText,
913                 evUpdatedRtpText,
914
915                         /* Radio Screenshow Support */
916                 evUpdatedRassSlidePic,
917                 evUpdatedRassInteractivePicMask,
918
919                 evVideoSizeChanged,
920                 evVideoFramerateChanged,
921                 evVideoProgressiveChanged,
922
923                 evBuffering,
924                 evGstreamerPlayStarted,
925
926                 evStopped,
927
928                 evHBBTVInfo,
929
930                 evUser = 0x100
931         };
932 };
933
934 SWIG_IGNORE(iPlayableService);
935 class iPlayableService: public iPlayableService_ENUMS, public iObject
936 {
937 #ifdef SWIG
938         iPlayableService();
939         ~iPlaybleService();
940 #endif
941         friend class iServiceHandler;
942 public:
943 #ifndef SWIG
944         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
945 #endif
946         virtual RESULT start()=0;
947         virtual RESULT stop()=0;
948                         /* might have to be changed... */
949         virtual RESULT setTarget(int target)=0;
950         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
951         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
952         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
953         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
954         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
955         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
956         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
957         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
958         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
959         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
960         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
961         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
962         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
963         virtual SWIG_VOID(RESULT) streamed(ePtr<iStreamedService> &SWIG_OUTPUT)=0;
964         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
965 };
966 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
967
968 class iRecordableService_ENUMS
969 {
970 #ifdef SWIG
971         iRecordableService_ENUMS();
972         ~iRecordableService_ENUMS();
973 #endif
974 public:
975         enum {
976                 evStart,
977                 evEnd,
978                 evTunedIn,
979                 evTuneFailed,
980                 evRecordRunning,
981                 evRecordStopped,
982                 evNewProgramInfo,
983                 evRecordFailed,
984                 evRecordWriteError,
985                 evNewEventInfo,
986                 evRecordAborted,
987         };
988         enum {
989                 NoError=0,
990                 errOpenRecordFile=-1,
991                 errNoDemuxAvailable=-2,
992                 errNoTsRecorderAvailable=-3,
993                 errDiskFull=-4,
994                 errTuneFailed=-255,
995                 errMisconfiguration = -256,
996                 errNoResources = -257,
997         };
998 };
999
1000 SWIG_IGNORE(iRecordableService);
1001 class iRecordableService: public iRecordableService_ENUMS, public iObject
1002 {
1003 #ifdef SWIG
1004         iRecordableService();
1005         ~iRecordableService();
1006 #endif
1007 public:
1008 #ifndef SWIG
1009         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
1010 #endif
1011         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
1012         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, bool descramble = true, bool recordecm = false)=0;
1013         virtual RESULT prepareStreaming(bool descramble = true, bool includeecm = false)=0;
1014         virtual RESULT start(bool simulate=false)=0;
1015         virtual RESULT stop()=0;
1016         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
1017         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
1018         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
1019 };
1020 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
1021
1022 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
1023
1024 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
1025 {
1026         return New_iRecordableServicePtr(c);
1027 }
1028
1029 #ifndef SWIG
1030 #ifdef PYTHON_REFCOUNT_DEBUG
1031 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
1032 {
1033         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
1034 }
1035 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
1036 #else
1037 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
1038 {
1039         return New_iRecordableServicePtr(ptr);
1040 }
1041 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
1042 #endif
1043 #endif // SWIG
1044
1045 SWIG_IGNORE(iServiceHandler);
1046 class iServiceHandler: public iObject
1047 {
1048 #ifdef SWIG
1049         iServiceHandler();
1050         ~iServiceHandler();
1051 #endif
1052 public:
1053         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
1054         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
1055         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
1056         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
1057         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
1058 };
1059 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
1060
1061 #endif