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                 sLiveStreamDemuxId,
 364
 365                 sUser = 0x100
 366         };
 367         enum {
 368                 resNA = -1,
 369                 resIsString = -2,
 370                 resIsPyObject = -3
 371         };
 372 };
 373
 374 /* some words to structs like struct iServiceInformation_ENUMS
 375 For some classes we need in python just the SmartPointer Variants.
 376 So we prevent building wrapper classes for the non smart pointer classes with the SWIG_IGNORE makro.
 377 But now we have the problem that swig do not export enums for smart pointer classes (i dont know why).
 378 So we move all enum's to own classes (with _ENUMS as name ending) and let our real
 379 class inherit from the *_ENUMS class. This *_ENUMS classes are normally exportet via swig to python.
 380 But in the python code we doesn't like to write iServiceInformation_ENUMS.sVideoType....
 381 we like to write iServiceInformation.sVideoType.
 382 So until swig have no Solution for this Problem we call in lib/python/Makefile.am a python script named
 383 enigma_py_patcher.py to remove the "_ENUMS" strings in enigma.py at all needed locations. */
 384
 385 SWIG_IGNORE(iServiceInformation);
 386 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
 387 {
 388 #ifdef SWIG
 389         iServiceInformation();
 390         ~iServiceInformation();
 391 #endif
 392 public:
 393         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
 394         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
 395
 396         virtual int getInfo(int w);
 397         virtual std::string getInfoString(int w);
 398         virtual PyObject *getInfoObject(int w);
 399
 400         virtual int setInfo(int w, int v);
 401         virtual int setInfoString(int w, const char *v);
 402 };
 403 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 404
 405 class iFrontendInformation_ENUMS
 406 {
 407 #ifdef SWIG
 408         iFrontendInformation_ENUMS();
 409         ~iFrontendInformation_ENUMS();
 410 #endif
 411 public:
 412         enum {
 413                 bitErrorRate,
 414                 signalPower,
 415                 signalQuality,
 416                 lockState,
 417                 syncState,
 418                 frontendNumber,
 419                 signalQualitydB,
 420         };
 421 };
 422
 423 SWIG_IGNORE(iFrontendInformation);
 424 class iFrontendInformation: public iFrontendInformation_ENUMS, public iObject
 425 {
 426 #ifdef SWIG
 427         iFrontendInformation();
 428         ~iFrontendInformation();
 429 #endif
 430 public:
 431         virtual int getFrontendInfo(int w)=0;
 432         virtual PyObject *getFrontendData()=0;
 433         virtual PyObject *getFrontendStatus()=0;
 434         virtual PyObject *getTransponderData(bool original)=0;
 435         virtual PyObject *getAll(bool original)=0; // a sum of getFrontendData/Status/TransponderData
 436 };
 437 SWIG_TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
 438
 439 SWIG_IGNORE(iPauseableService);
 440 class iPauseableService: public iObject
 441 {
 442 #ifdef SWIG
 443         iPausableService();
 444         ~iPausableService();
 445 #endif
 446 public:
 447
 448                 /* this will set the *state* directly. So just call a SINGLE function of those at a time. */
 449         virtual RESULT pause()=0;
 450         virtual RESULT unpause()=0;
 451
 452                 /* hm. */
 453         virtual RESULT setSlowMotion(int ratio=0)=0;
 454         virtual RESULT setFastForward(int ratio=0)=0;
 455 };
 456 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 457
 458 class iSeekableService_ENUMS
 459 {
 460 #ifdef SWIG
 461         iSeekableService_ENUMS();
 462         ~iSeekableService_ENUMS();
 463 #endif
 464 public:
 465         enum { dirForward = +1, dirBackward = -1 };
 466 };
 467
 468 SWIG_IGNORE(iSeekableService);
 469 class iSeekableService: public iSeekableService_ENUMS, public iObject
 470 {
 471 #ifdef SWIG
 472         iSeekableService();
 473         ~iSeekableService();
 474 #endif
 475 public:
 476         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 477         virtual RESULT seekTo(pts_t to)=0;
 478         virtual RESULT seekRelative(int direction, pts_t to)=0;
 479         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 480                 /* if you want to do several seeks in a row, you can enable the trickmode.
 481                    audio will be switched off, sync will be disabled etc. */
 482         virtual RESULT setTrickmode(int trick=0)=0;
 483         virtual RESULT isCurrentlySeekable()=0;
 484         virtual RESULT seekChapter(int) { return -1; }
 485         virtual RESULT seekTitle(int) { return -1; }
 486 };
 487 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 488
 489 struct iAudioTrackInfo
 490 {
 491 #ifndef SWIG
 492         std::string m_description;
 493         std::string m_language; /* iso639 */
 494         int m_pid; /* for association with the stream. */
 495 #endif
 496         std::string getDescription() { return m_description; }
 497         std::string getLanguage() { return m_language; }
 498         int getPID() { return m_pid; }
 499 };
 500 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 501
 502 SWIG_IGNORE(iAudioTrackSelection);
 503 class iAudioTrackSelection: public iObject
 504 {
 505 #ifdef SWIG
 506         iAudioTrackSelection();
 507         ~iAudioTrackSelection();
 508 #endif
 509 public:
 510         virtual int getNumberOfTracks()=0;
 511         virtual RESULT selectTrack(unsigned int i)=0;
 512         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 513         virtual int getCurrentTrack()=0;
 514 };
 515 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 516
 517 class iAudioChannelSelection_ENUMS
 518 {
 519 #ifdef SWIG
 520         iAudioChannelSelection_ENUMS();
 521         ~iAudioChannelSelection_ENUMS();
 522 #endif
 523 public:
 524         enum { LEFT, STEREO, RIGHT };
 525 };
 526
 527 SWIG_IGNORE(iAudioChannelSelection);
 528 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
 529 {
 530 #ifdef SWIG
 531         iAudioChannelSelection();
 532         ~iAudioChannelSelection();
 533 #endif
 534 public:
 535         virtual int getCurrentChannel()=0;
 536         virtual RESULT selectChannel(int i)=0;
 537 };
 538 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
 539
 540 SWIG_IGNORE(iAudioDelay);
 541 class iAudioDelay: public iObject
 542 {
 543 #ifdef SWIG
 544         iAudioDelay();
 545         ~iAudioDelay();
 546 #endif
 547 public:
 548         virtual int getAC3Delay()=0;
 549         virtual int getPCMDelay()=0;
 550         virtual void setAC3Delay(int)=0;
 551         virtual void setPCMDelay(int)=0;
 552 };
 553 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
 554
 555 class iRdsDecoder_ENUMS
 556 {
 557 #ifdef SWIG
 558         iRdsDecoder_ENUMS();
 559         ~iRdsDecoder_ENUMS();
 560 #endif
 561 public:
 562         enum { RadioText, RtpText };
 563 };
 564
 565 SWIG_IGNORE(iRdsDecoder);
 566 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
 567 {
 568 #ifdef SWIG
 569         iRdsDecoder();
 570         ~iRdsDecoder();
 571 #endif
 572 public:
 573         virtual std::string getText(int x=RadioText)=0;
 574         virtual void showRassSlidePicture()=0;
 575         virtual void showRassInteractivePic(int page, int subpage)=0;
 576         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
 577 };
 578 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
 579
 580 SWIG_IGNORE(iSubserviceList);
 581 class iSubserviceList: public iObject
 582 {
 583 #ifdef SWIG
 584         iSubserviceList();
 585         ~iSubserviceList();
 586 #endif
 587 public:
 588         virtual int getNumberOfSubservices()=0;
 589         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
 590 };
 591 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
 592
 593 SWIG_IGNORE(iTimeshiftService);
 594 class iTimeshiftService: public iObject
 595 {
 596 #ifdef SWIG
 597         iTimeshiftService();
 598         ~iTimeshiftService();
 599 #endif
 600 public:
 601         virtual RESULT startTimeshift()=0;
 602         virtual RESULT stopTimeshift(bool swToLive=true)=0;
 603         virtual RESULT setNextPlaybackFile(const char *fn)=0; // not needed by our internal timeshift.. but external plugin...
 604
 605         virtual int isTimeshiftActive()=0;
 606                         /* this essentially seeks to the relative end of the timeshift buffer */
 607         virtual RESULT activateTimeshift()=0;
 608 };
 609 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
 610
 611         /* not related to eCueSheet */
 612
 613 class iCueSheet_ENUMS
 614 {
 615 #ifdef SWIG
 616         iCueSheet_ENUMS();
 617         ~iCueSheet_ENUMS();
 618 #endif
 619 public:
 620         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
 621 };
 622
 623 SWIG_IGNORE(iCueSheet);
 624 class iCueSheet: public iCueSheet_ENUMS, public iObject
 625 {
 626 #ifdef SWIG
 627         iCueSheet();
 628         ~iCueSheet();
 629 #endif
 630 public:
 631         /* returns a list of (pts, what)-tuples */
 632         virtual PyObject *getCutList() = 0;
 633         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
 634         virtual void setCutListEnable(int enable) = 0;
 635 };
 636 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
 637
 638 class eWidget;
 639 class PyList;
 640
 641 SWIG_IGNORE(iSubtitleOutput);
 642 class iSubtitleOutput: public iObject
 643 {
 644 public:
 645         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
 646         virtual RESULT disableSubtitles(eWidget *parent)=0;
 647         virtual PyObject *getSubtitleList()=0;
 648         virtual PyObject *getCachedSubtitle()=0;
 649 };
 650 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
 651
 652 SWIG_IGNORE(iMutableServiceList);
 653 class iMutableServiceList: public iObject
 654 {
 655 #ifdef SWIG
 656         iMutableServiceList();
 657         ~iMutableServiceList();
 658 #endif
 659 public:
 660                 /* flush changes */
 661         virtual RESULT flushChanges()=0;
 662                 /* adds a service to a list */
 663         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
 664                 /* removes a service from a list */
 665         virtual RESULT removeService(eServiceReference &ref)=0;
 666                 /* moves a service in a list, only if list suppports a specific sort method. */
 667                 /* pos is the new, absolute position from 0..size-1 */
 668         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 669                 /* set name of list, for bouquets this is the visible bouquet name */
 670         virtual RESULT setListName(const std::string &name)=0;
 671 };
 672 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 673
 674 SWIG_IGNORE(iListableService);
 675 class iListableService: public iObject
 676 {
 677 #ifdef SWIG
 678         iListableService();
 679         ~iListableService();
 680 #endif
 681 public:
 682 #ifndef SWIG
 683                 /* legacy interface: get a list */
 684         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
 685 #endif
 686         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
 687
 688                 /* new, shiny interface: streaming. */
 689         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 690
 691                 /* use this for sorting. output is not sorted because of either
 692                  - performance reasons: the whole list must be buffered or
 693                  - the interface would be restricted to a list. streaming
 694                    (as well as a future "active" extension) won't be possible.
 695                 */
 696         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 697
 698         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 699 };
 700 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 701
 702 #ifndef SWIG
 703         /* a helper class which can be used as argument to stl's sort(). */
 704 class iListableServiceCompare
 705 {
 706         ePtr<iListableService> m_list;
 707 public:
 708         iListableServiceCompare(iListableService *list): m_list(list) { }
 709         bool operator()(const eServiceReference &a, const eServiceReference &b)
 710         {
 711                 return m_list->compareLessEqual(a, b);
 712         }
 713 };
 714 #endif
 715
 716 SWIG_IGNORE(iServiceOfflineOperations);
 717 class iServiceOfflineOperations: public iObject
 718 {
 719 #ifdef SWIG
 720         iServiceOfflineOperations();
 721         ~iServiceOfflineOperations();
 722 #endif
 723 public:
 724                 /* to delete a service, forever. */
 725         virtual RESULT deleteFromDisk(int simulate=1)=0;
 726
 727                 /* for transferring a service... */
 728         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 729
 730                 /* a blocking call to reindex a file */
 731         virtual int reindex() = 0;
 732
 733                 // TODO: additional stuff, like a conversion interface?
 734 };
 735 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 736
 737 SWIG_IGNORE(iStreamableService);
 738 class iStreamableService: public iObject
 739 {
 740 #ifdef SWIG
 741         iStreamableService();
 742         ~iStreamableService();
 743 #endif
 744 public:
 745                 /* returns a dict:
 746                         { "demux": <n>,
 747                           "pids": [(x,type),(y,type),(z,type),..],
 748                           ...
 749                         }
 750                         with type being "video", "audio", "pmt", "pat"...
 751                 */
 752         virtual PyObject *getStreamingData()=0;
 753 };
 754 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
 755
 756 SWIG_IGNORE(iStreamedService);
 757 class iStreamedService: public iObject
 758 {
 759 #ifdef SWIG
 760         iStreamedService();
 761         ~iStreamedService();
 762 #endif
 763 public:
 764         virtual PyObject *getBufferCharge()=0;
 765         virtual int setBufferSize(int size)=0;
 766 };
 767 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamedService>, iStreamedServicePtr);
 768
 769 class iServiceKeys_ENUMS
 770 {
 771 #ifdef SWIG
 772         iServiceKeys_ENUMS();
 773         ~iServiceKeys_ENUMS();
 774 #endif
 775 public:
 776         enum {
 777                 keyLeft,
 778                 keyRight,
 779                 keyUp,
 780                 keyDown,
 781                 keyOk,
 782                 keyUser = 0x100
 783         };
 784 };
 785
 786 SWIG_IGNORE(iServiceKeys);
 787 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
 788 {
 789 #ifdef SWIG
 790         iServiceKeys();
 791         ~iServiceKeys();
 792 #endif
 793 public:
 794         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
 795 };
 796 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
 797
 798 class iPlayableService_ENUMS
 799 {
 800 #ifdef SWIG
 801         iPlayableService_ENUMS();
 802         ~iPlayableService_ENUMS();
 803 #endif
 804 public:
 805         enum {
 806                         /* these first two events are magical, and should only
 807                            be generated if you know what you're doing. */
 808                 evStart,
 809                 evEnd,
 810
 811                 evTunedIn,
 812                 evTuneFailed,
 813
 814                         /* when iServiceInformation is implemented:*/
 815                 evUpdatedEventInfo,
 816                 evUpdatedInfo,
 817
 818                         /* when seek() is implemented: */
 819                 evSeekableStatusChanged, /* for example when timeshifting */
 820
 821                 evEOF,
 822                 evSOF, /* bounced against start of file (when seeking backwards) */
 823
 824                         /* when cueSheet is implemented */
 825                 evCuesheetChanged,
 826
 827                         /* when rdsDecoder is implemented */
 828                 evUpdatedRadioText,
 829                 evUpdatedRtpText,
 830
 831                         /* Radio Screenshow Support */
 832                 evUpdatedRassSlidePic,
 833                 evUpdatedRassInteractivePicMask,
 834
 835                 evVideoSizeChanged,
 836                 evVideoFramerateChanged,
 837                 evVideoProgressiveChanged,
 838
 839                 evBuffering,
 840
 841                 evStopped,
 842                 evHBBTVInfo,
 843
 844                 evUser = 0x100
 845         };
 846 };
 847
 848 SWIG_IGNORE(iPlayableService);
 849 class iPlayableService: public iPlayableService_ENUMS, public iObject
 850 {
 851 #ifdef SWIG
 852         iPlayableService();
 853         ~iPlaybleService();
 854 #endif
 855         friend class iServiceHandler;
 856 public:
 857 #ifndef SWIG
 858         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 859 #endif
 860         virtual RESULT start()=0;
 861         virtual RESULT stop()=0;
 862                         /* might have to be changed... */
 863         virtual RESULT setTarget(int target)=0;
 864         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 865         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 866         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 867         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 868         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
 869         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 870         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 871         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
 872         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
 873         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
 874         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
 875         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
 876         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 877         virtual SWIG_VOID(RESULT) streamed(ePtr<iStreamedService> &SWIG_OUTPUT)=0;
 878         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
 879 };
 880 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 881
 882 class iRecordableService_ENUMS
 883 {
 884 #ifdef SWIG
 885         iRecordableService_ENUMS();
 886         ~iRecordableService_ENUMS();
 887 #endif
 888 public:
 889         enum {
 890                 evStart,
 891                 evEnd,
 892                 evTunedIn,
 893                 evTuneFailed,
 894                 evRecordRunning,
 895                 evRecordStopped,
 896                 evNewProgramInfo,
 897                 evRecordFailed,
 898                 evRecordWriteError,
 899                 evNewEventInfo
 900         };
 901         enum {
 902                 NoError=0,
 903                 errOpenRecordFile=-1,
 904                 errNoDemuxAvailable=-2,
 905                 errNoTsRecorderAvailable=-3,
 906                 errDiskFull=-4,
 907                 errTuneFailed=-255,
 908                 errMisconfiguration = -256,
 909                 errNoResources = -257,
 910         };
 911 };
 912
 913 SWIG_IGNORE(iRecordableService);
 914 class iRecordableService: public iRecordableService_ENUMS, public iObject
 915 {
 916 #ifdef SWIG
 917         iRecordableService();
 918         ~iRecordableService();
 919 #endif
 920 public:
 921 #ifndef SWIG
 922         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
 923 #endif
 924         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
 925         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;
 926         virtual RESULT prepareStreaming()=0;
 927         virtual RESULT start(bool simulate=false)=0;
 928         virtual RESULT stop()=0;
 929         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 930         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 931         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 932 };
 933 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 934
 935 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
 936
 937 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
 938 {
 939         return New_iRecordableServicePtr(c);
 940 }
 941
 942 #ifndef SWIG
 943 #ifdef PYTHON_REFCOUNT_DEBUG
 944 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
 945 {
 946         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
 947 }
 948 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
 949 #else
 950 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
 951 {
 952         return New_iRecordableServicePtr(ptr);
 953 }
 954 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
 955 #endif
 956 #endif // SWIG
 957
 958 SWIG_IGNORE(iServiceHandler);
 959 class iServiceHandler: public iObject
 960 {
 961 #ifdef SWIG
 962         iServiceHandler();
 963         ~iServiceHandler();
 964 #endif
 965 public:
 966         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 967         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 968         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 969         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 970         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 971 };
 972 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 973
 974 #endif