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