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