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