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