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