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