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);
 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         virtual RESULT pause()=0;
 396         virtual RESULT unpause()=0;
 397
 398                 /* hm. */
 399         virtual RESULT setSlowMotion(int ratio=0)=0;
 400         virtual RESULT setFastForward(int ratio=0)=0;
 401 };
 402 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 403
 404 class iSeekableService_ENUMS
 405 {
 406 #ifdef SWIG
 407         iSeekableService_ENUMS();
 408         ~iSeekableService_ENUMS();
 409 #endif
 410 public:
 411         enum { dirForward = +1, dirBackward = -1 };
 412 };
 413
 414 SWIG_IGNORE(iSeekableService);
 415 class iSeekableService: public iSeekableService_ENUMS, public iObject
 416 {
 417 #ifdef SWIG
 418         iSeekableService();
 419         ~iSeekableService();
 420 #endif
 421 public:
 422         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 423         virtual RESULT seekTo(pts_t to)=0;
 424         virtual RESULT seekRelative(int direction, pts_t to)=0;
 425         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 426                 /* if you want to do several seeks in a row, you can enable the trickmode.
 427                    audio will be switched off, sync will be disabled etc. */
 428         virtual RESULT setTrickmode(int trick=0)=0;
 429         virtual RESULT isCurrentlySeekable()=0;
 430         virtual RESULT seekChapter(int) { return -1; }
 431         virtual RESULT seekTitle(int) { return -1; }
 432 };
 433 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 434
 435 struct iAudioTrackInfo
 436 {
 437 #ifndef SWIG
 438         std::string m_description;
 439         std::string m_language; /* iso639 */
 440         int m_pid; /* for association with the stream. */
 441 #endif
 442         std::string getDescription() { return m_description; }
 443         std::string getLanguage() { return m_language; }
 444         int getPID() { return m_pid; }
 445 };
 446 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 447
 448 SWIG_IGNORE(iAudioTrackSelection);
 449 class iAudioTrackSelection: public iObject
 450 {
 451 #ifdef SWIG
 452         iAudioTrackSelection();
 453         ~iAudioTrackSelection();
 454 #endif
 455 public:
 456         virtual int getNumberOfTracks()=0;
 457         virtual RESULT selectTrack(unsigned int i)=0;
 458         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 459         virtual int getCurrentTrack()=0;
 460 };
 461 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 462
 463 class iAudioChannelSelection_ENUMS
 464 {
 465 #ifdef SWIG
 466         iAudioChannelSelection_ENUMS();
 467         ~iAudioChannelSelection_ENUMS();
 468 #endif
 469 public:
 470         enum { LEFT, STEREO, RIGHT };
 471 };
 472
 473 SWIG_IGNORE(iAudioChannelSelection);
 474 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
 475 {
 476 #ifdef SWIG
 477         iAudioChannelSelection();
 478         ~iAudioChannelSelection();
 479 #endif
 480 public:
 481         virtual int getCurrentChannel()=0;
 482         virtual RESULT selectChannel(int i)=0;
 483 };
 484 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
 485
 486 SWIG_IGNORE(iAudioDelay);
 487 class iAudioDelay: public iObject
 488 {
 489 #ifdef SWIG
 490         iAudioDelay();
 491         ~iAudioDelay();
 492 #endif
 493 public:
 494         virtual int getAC3Delay()=0;
 495         virtual int getPCMDelay()=0;
 496         virtual void setAC3Delay(int)=0;
 497         virtual void setPCMDelay(int)=0;
 498 };
 499 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
 500
 501 class iRdsDecoder_ENUMS
 502 {
 503 #ifdef SWIG
 504         iRdsDecoder_ENUMS();
 505         ~iRdsDecoder_ENUMS();
 506 #endif
 507 public:
 508         enum { RadioText, RtpText };
 509 };
 510
 511 SWIG_IGNORE(iRdsDecoder);
 512 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
 513 {
 514 #ifdef SWIG
 515         iRdsDecoder();
 516         ~iRdsDecoder();
 517 #endif
 518 public:
 519         virtual std::string getText(int x=RadioText)=0;
 520         virtual void showRassSlidePicture()=0;
 521         virtual void showRassInteractivePic(int page, int subpage)=0;
 522         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
 523 };
 524 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
 525
 526 SWIG_IGNORE(iSubserviceList);
 527 class iSubserviceList: public iObject
 528 {
 529 #ifdef SWIG
 530         iSubserviceList();
 531         ~iSubserviceList();
 532 #endif
 533 public:
 534         virtual int getNumberOfSubservices()=0;
 535         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
 536 };
 537 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
 538
 539 SWIG_IGNORE(iTimeshiftService);
 540 class iTimeshiftService: public iObject
 541 {
 542 #ifdef SWIG
 543         iTimeshiftService();
 544         ~iTimeshiftService();
 545 #endif
 546 public:
 547         virtual RESULT startTimeshift()=0;
 548         virtual RESULT stopTimeshift()=0;
 549
 550         virtual int isTimeshiftActive()=0;
 551                         /* this essentially seeks to the relative end of the timeshift buffer */
 552         virtual RESULT activateTimeshift()=0;
 553 };
 554 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
 555
 556         /* not related to eCueSheet */
 557
 558 class iCueSheet_ENUMS
 559 {
 560 #ifdef SWIG
 561         iCueSheet_ENUMS();
 562         ~iCueSheet_ENUMS();
 563 #endif
 564 public:
 565         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
 566 };
 567
 568 SWIG_IGNORE(iCueSheet);
 569 class iCueSheet: public iCueSheet_ENUMS, public iObject
 570 {
 571 #ifdef SWIG
 572         iCueSheet();
 573         ~iCueSheet();
 574 #endif
 575 public:
 576         /* returns a list of (pts, what)-tuples */
 577         virtual PyObject *getCutList() = 0;
 578         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
 579         virtual void setCutListEnable(int enable) = 0;
 580 };
 581 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
 582
 583 class eWidget;
 584 class PyList;
 585
 586 SWIG_IGNORE(iSubtitleOutput);
 587 class iSubtitleOutput: public iObject
 588 {
 589 public:
 590         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
 591         virtual RESULT disableSubtitles(eWidget *parent)=0;
 592         virtual PyObject *getSubtitleList()=0;
 593         virtual PyObject *getCachedSubtitle()=0;
 594 };
 595 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
 596
 597 SWIG_IGNORE(iMutableServiceList);
 598 class iMutableServiceList: public iObject
 599 {
 600 #ifdef SWIG
 601         iMutableServiceList();
 602         ~iMutableServiceList();
 603 #endif
 604 public:
 605                 /* flush changes */
 606         virtual RESULT flushChanges()=0;
 607                 /* adds a service to a list */
 608         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
 609                 /* removes a service from a list */
 610         virtual RESULT removeService(eServiceReference &ref)=0;
 611                 /* moves a service in a list, only if list suppports a specific sort method. */
 612                 /* pos is the new, absolute position from 0..size-1 */
 613         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 614                 /* set name of list, for bouquets this is the visible bouquet name */
 615         virtual RESULT setListName(const std::string &name)=0;
 616 };
 617 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 618
 619 SWIG_IGNORE(iListableService);
 620 class iListableService: public iObject
 621 {
 622 #ifdef SWIG
 623         iListableService();
 624         ~iListableService();
 625 #endif
 626 public:
 627 #ifndef SWIG
 628                 /* legacy interface: get a list */
 629         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
 630 #endif
 631         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
 632
 633                 /* new, shiny interface: streaming. */
 634         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 635
 636                 /* use this for sorting. output is not sorted because of either
 637                  - performance reasons: the whole list must be buffered or
 638                  - the interface would be restricted to a list. streaming
 639                    (as well as a future "active" extension) won't be possible.
 640                 */
 641         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 642
 643         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 644 };
 645 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 646
 647 #ifndef SWIG
 648         /* a helper class which can be used as argument to stl's sort(). */
 649 class iListableServiceCompare
 650 {
 651         ePtr<iListableService> m_list;
 652 public:
 653         iListableServiceCompare(iListableService *list): m_list(list) { }
 654         bool operator()(const eServiceReference &a, const eServiceReference &b)
 655         {
 656                 return m_list->compareLessEqual(a, b);
 657         }
 658 };
 659 #endif
 660
 661 SWIG_IGNORE(iServiceOfflineOperations);
 662 class iServiceOfflineOperations: public iObject
 663 {
 664 #ifdef SWIG
 665         iServiceOfflineOperations();
 666         ~iServiceOfflineOperations();
 667 #endif
 668 public:
 669                 /* to delete a service, forever. */
 670         virtual RESULT deleteFromDisk(int simulate=1)=0;
 671
 672                 /* for transferring a service... */
 673         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 674
 675                 // TODO: additional stuff, like a conversion interface?
 676 };
 677 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 678
 679 SWIG_IGNORE(iStreamableService);
 680 class iStreamableService: public iObject
 681 {
 682 #ifdef SWIG
 683         iStreamableService();
 684         ~iStreamableService();
 685 #endif
 686 public:
 687                 /* returns a dict:
 688                         { "demux": <n>,
 689                           "pids": [(x,type),(y,type),(z,type),..],
 690                           ...
 691                         }
 692                         with type being "video", "audio", "pmt", "pat"...
 693                 */
 694         virtual PyObject *getStreamingData()=0;
 695 };
 696 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
 697
 698 class iServiceKeys_ENUMS
 699 {
 700 #ifdef SWIG
 701         iServiceKeys_ENUMS();
 702         ~iServiceKeys_ENUMS();
 703 #endif
 704 public:
 705         enum {
 706                 keyLeft,
 707                 keyRight,
 708                 keyUp,
 709                 keyDown,
 710                 keyOk,
 711                 keyUser = 0x100
 712         };
 713 };
 714
 715 SWIG_IGNORE(iServiceKeys);
 716 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
 717 {
 718 #ifdef SWIG
 719         iServiceKeys();
 720         ~iServiceKeys();
 721 #endif
 722 public:
 723         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
 724 };
 725 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
 726
 727 class iPlayableService_ENUMS
 728 {
 729 #ifdef SWIG
 730         iPlayableService_ENUMS();
 731         ~iPlayableService_ENUMS();
 732 #endif
 733 public:
 734         enum {
 735                         /* these first two events are magical, and should only
 736                            be generated if you know what you're doing. */
 737                 evStart,
 738                 evEnd,
 739
 740                 evTunedIn,
 741                 evTuneFailed,
 742
 743                         /* when iServiceInformation is implemented:*/
 744                 evUpdatedEventInfo,
 745                 evUpdatedInfo,
 746
 747                         /* when seek() is implemented: */
 748                 evSeekableStatusChanged, /* for example when timeshifting */
 749
 750                 evEOF,
 751                 evSOF, /* bounced against start of file (when seeking backwards) */
 752
 753                         /* when cueSheet is implemented */
 754                 evCuesheetChanged,
 755
 756                         /* when rdsDecoder is implemented */
 757                 evUpdatedRadioText,
 758                 evUpdatedRtpText,
 759
 760                         /* Radio Screenshow Support */
 761                 evUpdatedRassSlidePic,
 762                 evUpdatedRassInteractivePicMask,
 763
 764                 evVideoSizeChanged,
 765                 evVideoFramerateChanged,
 766                 evVideoProgressiveChanged,
 767
 768                 evStopped,
 769
 770                 evUser = 0x100
 771         };
 772 };
 773
 774 SWIG_IGNORE(iPlayableService);
 775 class iPlayableService: public iPlayableService_ENUMS, public iObject
 776 {
 777 #ifdef SWIG
 778         iPlayableService();
 779         ~iPlaybleService();
 780 #endif
 781         friend class iServiceHandler;
 782 public:
 783 #ifndef SWIG
 784         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 785 #endif
 786         virtual RESULT start()=0;
 787         virtual RESULT stop()=0;
 788                         /* might have to be changed... */
 789         virtual RESULT setTarget(int target)=0;
 790         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 791         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 792         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 793         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 794         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
 795         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 796         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 797         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
 798         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
 799         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
 800         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
 801         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
 802         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 803         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
 804 };
 805 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 806
 807 class iRecordableService_ENUMS
 808 {
 809 #ifdef SWIG
 810         iRecordableService_ENUMS();
 811         ~iRecordableService_ENUMS();
 812 #endif
 813 public:
 814         enum {
 815                 evStart,
 816                 evEnd,
 817                 evTunedIn,
 818                 evTuneFailed,
 819                 evRecordRunning,
 820                 evRecordStopped,
 821                 evNewProgramInfo,
 822                 evRecordFailed,
 823                 evRecordWriteError
 824         };
 825         enum {
 826                 NoError=0,
 827                 errOpenRecordFile=-1,
 828                 errNoDemuxAvailable=-2,
 829                 errNoTsRecorderAvailable=-3,
 830                 errDiskFull=-4,
 831                 errTuneFailed=-255,
 832                 errMisconfiguration = -256,
 833                 errNoResources = -257,
 834         };
 835 };
 836
 837 SWIG_IGNORE(iRecordableService);
 838 class iRecordableService: public iRecordableService_ENUMS, public iObject
 839 {
 840 #ifdef SWIG
 841         iRecordableService();
 842         ~iRecordableService();
 843 #endif
 844 public:
 845 #ifndef SWIG
 846         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
 847 #endif
 848         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
 849         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1)=0;
 850         virtual RESULT prepareStreaming()=0;
 851         virtual RESULT start(bool simulate=false)=0;
 852         virtual RESULT stop()=0;
 853         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 854         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 855 };
 856 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 857
 858 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
 859
 860 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
 861 {
 862         return New_iRecordableServicePtr(c);
 863 }
 864
 865 #ifndef SWIG
 866 #ifdef PYTHON_REFCOUNT_DEBUG
 867 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
 868 {
 869         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
 870 }
 871 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
 872 #else
 873 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
 874 {
 875         return New_iRecordableServicePtr(ptr);
 876 }
 877 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
 878 #endif
 879 #endif // SWIG
 880
 881 SWIG_IGNORE(iServiceHandler);
 882 class iServiceHandler: public iObject
 883 {
 884 #ifdef SWIG
 885         iServiceHandler();
 886         ~iServiceHandler();
 887 #endif
 888 public:
 889         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 890         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 891         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 892         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 893         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 894 };
 895 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 896
 897 #endif