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