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