Add flag to services so we can mark services as dedicated 3D
[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                 sIsDedicated3D,
392
393                 sUser = 0x100
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 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
414 {
415 #ifdef SWIG
416         iServiceInformation();
417         ~iServiceInformation();
418 #endif
419 public:
420         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
421         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
422
423         virtual int getInfo(int w);
424         virtual std::string getInfoString(int w);
425         virtual ePtr<iServiceInfoContainer> getInfoObject(int w);
426         virtual ePtr<iDVBTransponderData> getTransponderData();
427         virtual void getAITApplications(std::map<int, std::string> &aitlist) {};
428         virtual void getCaIds(std::vector<int> &caids, std::vector<int> &ecmpids);
429         virtual long long getFileSize();
430
431         virtual int setInfo(int w, int v);
432         virtual int setInfoString(int w, const char *v);
433 };
434 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
435
436 class iFrontendInformation_ENUMS
437 {
438 #ifdef SWIG
439         iFrontendInformation_ENUMS();
440         ~iFrontendInformation_ENUMS();
441 #endif
442 public:
443         enum {
444                 bitErrorRate,
445                 signalPower,
446                 signalQuality,
447                 lockState,
448                 syncState,
449                 frontendNumber,
450                 signalQualitydB,
451                 frontendStatus,
452                 snrValue,
453                 frequency,
454         };
455 };
456
457 class iDVBFrontendData;
458 class iDVBFrontendStatus;
459 class iDVBTransponderData;
460
461 class iFrontendInformation: public iFrontendInformation_ENUMS, public iObject
462 {
463 #ifdef SWIG
464         iFrontendInformation();
465         ~iFrontendInformation();
466 #endif
467 public:
468         virtual int getFrontendInfo(int w)=0;
469         virtual ePtr<iDVBFrontendData> getFrontendData()=0;
470         virtual ePtr<iDVBFrontendStatus> getFrontendStatus()=0;
471         virtual ePtr<iDVBTransponderData> getTransponderData(bool original)=0;
472         void getAll() {}
473 };
474 SWIG_TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
475
476 SWIG_IGNORE(iPauseableService);
477 class iPauseableService: public iObject
478 {
479 #ifdef SWIG
480         iPausableService();
481         ~iPausableService();
482 #endif
483 public:
484
485                 /* this will set the *state* directly. So just call a SINGLE function of those at a time. */
486         virtual RESULT pause()=0;
487         virtual RESULT unpause()=0;
488
489                 /* hm. */
490         virtual RESULT setSlowMotion(int ratio=0)=0;
491         virtual RESULT setFastForward(int ratio=0)=0;
492 };
493 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
494
495 class iSeekableService_ENUMS
496 {
497 #ifdef SWIG
498         iSeekableService_ENUMS();
499         ~iSeekableService_ENUMS();
500 #endif
501 public:
502         enum { dirForward = +1, dirBackward = -1 };
503 };
504
505 SWIG_IGNORE(iSeekableService);
506 class iSeekableService: public iSeekableService_ENUMS, public iObject
507 {
508 #ifdef SWIG
509         iSeekableService();
510         ~iSeekableService();
511 #endif
512 public:
513         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
514         virtual RESULT seekTo(pts_t to)=0;
515         virtual RESULT seekRelative(int direction, pts_t to)=0;
516         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
517                 /* if you want to do several seeks in a row, you can enable the trickmode.
518                    audio will be switched off, sync will be disabled etc. */
519         virtual RESULT setTrickmode(int trick=0)=0;
520         virtual RESULT isCurrentlySeekable()=0;
521         virtual RESULT seekChapter(int) { return -1; }
522         virtual RESULT seekTitle(int) { return -1; }
523 };
524 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
525
526 struct iAudioTrackInfo
527 {
528 #ifndef SWIG
529         std::string m_description;
530         std::string m_language; /* iso639 */
531         int m_pid; /* for association with the stream. */
532 #endif
533         std::string getDescription() { return m_description; }
534         std::string getLanguage() { return m_language; }
535         int getPID() { return m_pid; }
536 };
537 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
538
539 SWIG_IGNORE(iAudioTrackSelection);
540 class iAudioTrackSelection: public iObject
541 {
542 #ifdef SWIG
543         iAudioTrackSelection();
544         ~iAudioTrackSelection();
545 #endif
546 public:
547         virtual int getNumberOfTracks()=0;
548         virtual RESULT selectTrack(unsigned int i)=0;
549         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
550         virtual int getCurrentTrack()=0;
551 };
552 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
553
554 class iAudioChannelSelection_ENUMS
555 {
556 #ifdef SWIG
557         iAudioChannelSelection_ENUMS();
558         ~iAudioChannelSelection_ENUMS();
559 #endif
560 public:
561         enum { LEFT, STEREO, RIGHT };
562 };
563
564 SWIG_IGNORE(iAudioChannelSelection);
565 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
566 {
567 #ifdef SWIG
568         iAudioChannelSelection();
569         ~iAudioChannelSelection();
570 #endif
571 public:
572         virtual int getCurrentChannel()=0;
573         virtual RESULT selectChannel(int i)=0;
574 };
575 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
576
577 SWIG_IGNORE(iAudioDelay);
578 class iAudioDelay: public iObject
579 {
580 #ifdef SWIG
581         iAudioDelay();
582         ~iAudioDelay();
583 #endif
584 public:
585         virtual int getAC3Delay()=0;
586         virtual int getPCMDelay()=0;
587         virtual void setAC3Delay(int)=0;
588         virtual void setPCMDelay(int)=0;
589 };
590 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
591
592 class iRdsDecoder_ENUMS
593 {
594 #ifdef SWIG
595         iRdsDecoder_ENUMS();
596         ~iRdsDecoder_ENUMS();
597 #endif
598 public:
599         enum { RadioText, RtpText };
600 };
601
602 SWIG_IGNORE(iRdsDecoder);
603 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
604 {
605 #ifdef SWIG
606         iRdsDecoder();
607         ~iRdsDecoder();
608 #endif
609 public:
610         virtual std::string getText(int x=RadioText)=0;
611         virtual void showRassSlidePicture()=0;
612         virtual void showRassInteractivePic(int page, int subpage)=0;
613         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
614 };
615 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
616
617 SWIG_IGNORE(iSubserviceList);
618 class iSubserviceList: public iObject
619 {
620 #ifdef SWIG
621         iSubserviceList();
622         ~iSubserviceList();
623 #endif
624 public:
625         virtual int getNumberOfSubservices()=0;
626         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
627 };
628 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
629
630 SWIG_IGNORE(iTimeshiftService);
631 class iTimeshiftService: public iObject
632 {
633 #ifdef SWIG
634         iTimeshiftService();
635         ~iTimeshiftService();
636 #endif
637 public:
638         virtual RESULT startTimeshift()=0;
639         virtual RESULT stopTimeshift(bool swToLive=true)=0;
640         virtual RESULT setNextPlaybackFile(const char *fn)=0; // not needed by our internal timeshift.. but external plugin...
641
642         virtual int isTimeshiftActive()=0;
643         virtual int isTimeshiftEnabled()=0;
644                         /* this essentially seeks to the relative end of the timeshift buffer */
645         virtual RESULT activateTimeshift()=0;
646         virtual RESULT saveTimeshiftFile()=0;
647         virtual std::string getTimeshiftFilename()=0;
648         virtual void switchToLive()=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(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 PyObject *getCutList() = 0;
674         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
675         virtual void setCutListEnable(int enable) = 0;
676 };
677 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
678
679 class PyList;
680
681 class eDVBTeletextSubtitlePage;
682 class eDVBSubtitlePage;
683 struct ePangoSubtitlePage;
684 class eRect;
685 struct gRegion;
686 struct gPixmap;
687
688 SWIG_IGNORE(iSubtitleUser);
689 class iSubtitleUser
690 {
691 public:
692         virtual void setPage(const eDVBTeletextSubtitlePage &p) = 0;
693         virtual void setPage(const eDVBSubtitlePage &p) = 0;
694         virtual void setPage(const ePangoSubtitlePage &p) = 0;
695         virtual void setPixmap(ePtr<gPixmap> &pixmap, gRegion changed, eRect dest) = 0;
696         virtual void destroy() = 0;
697 };
698
699 class iSubtitleOutput: public iObject
700 {
701 public:
702         struct SubtitleTrack
703         {
704                 int type;
705                 int pid;
706                 int page_number;
707                 int magazine_number;
708                 std::string language_code;
709         };
710
711         virtual RESULT enableSubtitles(iSubtitleUser *user, SubtitleTrack &track) = 0;
712         virtual RESULT disableSubtitles() = 0;
713         virtual RESULT getCachedSubtitle(SubtitleTrack &track) = 0;
714         virtual RESULT getSubtitleList(std::vector<SubtitleTrack> &subtitlelist) = 0;
715 };
716 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
717
718 SWIG_IGNORE(iMutableServiceList);
719 class iMutableServiceList: public iObject
720 {
721 #ifdef SWIG
722         iMutableServiceList();
723         ~iMutableServiceList();
724 #endif
725 public:
726                 /* flush changes */
727         virtual RESULT flushChanges()=0;
728                 /* adds a service to a list */
729         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
730                 /* removes a service from a list */
731         virtual RESULT removeService(eServiceReference &ref, bool renameBouquet=true)=0;
732                 /* moves a service in a list, only if list suppports a specific sort method. */
733                 /* pos is the new, absolute position from 0..size-1 */
734         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
735                 /* set name of list, for bouquets this is the visible bouquet name */
736         virtual RESULT setListName(const std::string &name)=0;
737 };
738 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
739
740 SWIG_IGNORE(iListableService);
741 class iListableService: public iObject
742 {
743 #ifdef SWIG
744         iListableService();
745         ~iListableService();
746 #endif
747 public:
748 #ifndef SWIG
749                 /* legacy interface: get a list */
750         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
751 #endif
752         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
753
754                 /* new, shiny interface: streaming. */
755         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
756
757                 /* use this for sorting. output is not sorted because of either
758                  - performance reasons: the whole list must be buffered or
759                  - the interface would be restricted to a list. streaming
760                    (as well as a future "active" extension) won't be possible.
761                 */
762         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
763
764         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
765 };
766 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
767
768 #ifndef SWIG
769         /* a helper class which can be used as argument to stl's sort(). */
770 class iListableServiceCompare
771 {
772         ePtr<iListableService> m_list;
773 public:
774         iListableServiceCompare(iListableService *list): m_list(list) { }
775         bool operator()(const eServiceReference &a, const eServiceReference &b)
776         {
777                 return m_list->compareLessEqual(a, b);
778         }
779 };
780 #endif
781
782 SWIG_IGNORE(iServiceOfflineOperations);
783 class iServiceOfflineOperations: public iObject
784 {
785 #ifdef SWIG
786         iServiceOfflineOperations();
787         ~iServiceOfflineOperations();
788 #endif
789 public:
790                 /* to delete a service, forever. */
791         virtual RESULT deleteFromDisk(int simulate=1)=0;
792
793                 /* for transferring a service... */
794         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
795
796                 /* a blocking call to reindex a file */
797         virtual int reindex() = 0;
798
799                 // TODO: additional stuff, like a conversion interface?
800 };
801 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
802
803 class iStreamData: public iObject
804 {
805 public:
806         virtual SWIG_VOID(RESULT) getAllPids(std::vector<int> &result) const = 0;
807         virtual SWIG_VOID(RESULT) getVideoPids(std::vector<int> &result) const = 0;
808         virtual SWIG_VOID(RESULT) getAudioPids(std::vector<int> &result) const = 0;
809         virtual SWIG_VOID(RESULT) getSubtitlePids(std::vector<int> &result) const = 0;
810         virtual SWIG_VOID(RESULT) getPmtPid(int &result) const = 0;
811         virtual SWIG_VOID(RESULT) getPatPid(int &result) const = 0;
812         virtual SWIG_VOID(RESULT) getPcrPid(int &result) const = 0;
813         virtual SWIG_VOID(RESULT) getTxtPid(int &result) const = 0;
814         virtual SWIG_VOID(RESULT) getServiceId(int &result) const = 0;
815         virtual SWIG_VOID(RESULT) getAdapterId(int &result) const = 0;
816         virtual SWIG_VOID(RESULT) getDemuxId(int &result) const = 0;
817         virtual SWIG_VOID(RESULT) getCaIds(std::vector<int> &caids, std::vector<int> &ecmpids) const = 0;
818 };
819
820 class iStreamableService: public iObject
821 {
822 #ifdef SWIG
823         iStreamableService();
824         ~iStreamableService();
825 #endif
826 public:
827         virtual ePtr<iStreamData> getStreamingData() = 0;
828 };
829 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
830
831 class iStreamBufferInfo: public iObject
832 {
833 public:
834         virtual int getBufferPercentage() const = 0;
835         virtual int getAverageInputRate() const = 0;
836         virtual int getAverageOutputRate() const = 0;
837         virtual int getBufferSpace() const = 0;
838         virtual int getBufferSize() const = 0;
839 };
840
841 class iStreamedService: public iObject
842 {
843 #ifdef SWIG
844         iStreamedService();
845         ~iStreamedService();
846 #endif
847 public:
848         virtual ePtr<iStreamBufferInfo> getBufferCharge()=0;
849         virtual int setBufferSize(int size)=0;
850 };
851 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamedService>, iStreamedServicePtr);
852
853 class iServiceKeys_ENUMS
854 {
855 #ifdef SWIG
856         iServiceKeys_ENUMS();
857         ~iServiceKeys_ENUMS();
858 #endif
859 public:
860         enum {
861                 keyLeft,
862                 keyRight,
863                 keyUp,
864                 keyDown,
865                 keyOk,
866                 keyUser = 0x100
867         };
868 };
869
870 SWIG_IGNORE(iServiceKeys);
871 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
872 {
873 #ifdef SWIG
874         iServiceKeys();
875         ~iServiceKeys();
876 #endif
877 public:
878         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
879 };
880 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
881
882 class iPlayableService_ENUMS
883 {
884 #ifdef SWIG
885         iPlayableService_ENUMS();
886         ~iPlayableService_ENUMS();
887 #endif
888 public:
889         enum {
890                         /* these first two events are magical, and should only
891                            be generated if you know what you're doing. */
892                 evStart,
893                 evEnd,
894
895                 evTunedIn,
896                 evTuneFailed,
897
898                         /* when iServiceInformation is implemented:*/
899                 evUpdatedEventInfo,
900                 evUpdatedInfo,
901                 evNewProgramInfo,
902
903                         /* when seek() is implemented: */
904                 evSeekableStatusChanged, /* for example when timeshifting */
905
906                 evEOF,
907                 evSOF, /* bounced against start of file (when seeking backwards) */
908
909                         /* when cueSheet is implemented */
910                 evCuesheetChanged,
911
912                         /* when rdsDecoder is implemented */
913                 evUpdatedRadioText,
914                 evUpdatedRtpText,
915
916                         /* Radio Screenshow Support */
917                 evUpdatedRassSlidePic,
918                 evUpdatedRassInteractivePicMask,
919
920                 evVideoSizeChanged,
921                 evVideoFramerateChanged,
922                 evVideoProgressiveChanged,
923
924                 evBuffering,
925                 evGstreamerPlayStarted,
926
927                 evStopped,
928
929                 evHBBTVInfo,
930
931                 evUser = 0x100
932         };
933 };
934
935 SWIG_IGNORE(iPlayableService);
936 class iPlayableService: public iPlayableService_ENUMS, public iObject
937 {
938 #ifdef SWIG
939         iPlayableService();
940         ~iPlaybleService();
941 #endif
942         friend class iServiceHandler;
943 public:
944 #ifndef SWIG
945         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
946 #endif
947         virtual RESULT start()=0;
948         virtual RESULT stop()=0;
949                         /* might have to be changed... */
950         virtual RESULT setTarget(int target)=0;
951         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
952         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
953         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
954         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
955         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
956         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
957         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
958         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
959         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
960         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
961         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
962         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
963         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
964         virtual SWIG_VOID(RESULT) streamed(ePtr<iStreamedService> &SWIG_OUTPUT)=0;
965         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
966 };
967 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
968
969 class iRecordableService_ENUMS
970 {
971 #ifdef SWIG
972         iRecordableService_ENUMS();
973         ~iRecordableService_ENUMS();
974 #endif
975 public:
976         enum {
977                 evStart,
978                 evEnd,
979                 evTunedIn,
980                 evTuneFailed,
981                 evRecordRunning,
982                 evRecordStopped,
983                 evNewProgramInfo,
984                 evRecordFailed,
985                 evRecordWriteError,
986                 evNewEventInfo,
987                 evRecordAborted,
988         };
989         enum {
990                 NoError=0,
991                 errOpenRecordFile=-1,
992                 errNoDemuxAvailable=-2,
993                 errNoTsRecorderAvailable=-3,
994                 errDiskFull=-4,
995                 errTuneFailed=-255,
996                 errMisconfiguration = -256,
997                 errNoResources = -257,
998         };
999 };
1000
1001 SWIG_IGNORE(iRecordableService);
1002 class iRecordableService: public iRecordableService_ENUMS, public iObject
1003 {
1004 #ifdef SWIG
1005         iRecordableService();
1006         ~iRecordableService();
1007 #endif
1008 public:
1009 #ifndef SWIG
1010         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
1011 #endif
1012         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
1013         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;
1014         virtual RESULT prepareStreaming(bool descramble = true, bool includeecm = false)=0;
1015         virtual RESULT start(bool simulate=false)=0;
1016         virtual RESULT stop()=0;
1017         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
1018         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
1019         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
1020 };
1021 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
1022
1023 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
1024
1025 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
1026 {
1027         return New_iRecordableServicePtr(c);
1028 }
1029
1030 #ifndef SWIG
1031 #ifdef PYTHON_REFCOUNT_DEBUG
1032 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
1033 {
1034         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
1035 }
1036 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
1037 #else
1038 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
1039 {
1040         return New_iRecordableServicePtr(ptr);
1041 }
1042 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
1043 #endif
1044 #endif // SWIG
1045
1046 SWIG_IGNORE(iServiceHandler);
1047 class iServiceHandler: public iObject
1048 {
1049 #ifdef SWIG
1050         iServiceHandler();
1051         ~iServiceHandler();
1052 #endif
1053 public:
1054         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
1055         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
1056         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
1057         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
1058         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
1059 };
1060 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
1061
1062 #endif