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         operator bool() const
 142         {
 143                 return valid();
 144         }
 145 #endif
 146         eServiceReference(int type, int flags, const std::string &path)
 147                 : type(type), flags(flags), path(path)
 148         {
 149                 memset(data, 0, sizeof(data));
 150         }
 151         eServiceReference(const std::string &string);
 152         std::string toString() const;
 153         std::string toCompareString() const;
 154         bool operator==(const eServiceReference &c) const
 155         {
 156                 if (type != c.type)
 157                         return 0;
 158                 return (memcmp(data, c.data, sizeof(int)*8)==0) && (path == c.path);
 159         }
 160         bool operator!=(const eServiceReference &c) const
 161         {
 162                 return !(*this == c);
 163         }
 164         bool operator<(const eServiceReference &c) const
 165         {
 166                 if (type < c.type)
 167                         return 1;
 168
 169                 if (type > c.type)
 170                         return 0;
 171
 172                 int r=memcmp(data, c.data, sizeof(int)*8);
 173                 if (r)
 174                         return r < 0;
 175                 return path < c.path;
 176         }
 177
 178         int valid() const
 179         {
 180                 return type != idInvalid;
 181         }
 182 };
 183
 184 SWIG_ALLOW_OUTPUT_SIMPLE(eServiceReference);
 185
 186 extern PyObject *New_eServiceReference(const eServiceReference &ref); // defined in enigma_python.i
 187
 188 #ifndef SWIG
 189 #ifdef PYTHON_REFCOUNT_DEBUG
 190 inline ePyObject Impl_New_eServiceReference(const char* file, int line, const eServiceReference &ref)
 191 {
 192         return ePyObject(New_eServiceReference(ref), file, line);
 193 }
 194 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(__FILE__, __LINE__, ref)
 195 #else
 196 inline ePyObject Impl_New_eServiceReference(const eServiceReference &ref)
 197 {
 198         return New_eServiceReference(ref);
 199 }
 200 #define NEW_eServiceReference(ref) Impl_New_eServiceReference(ref)
 201 #endif
 202 #endif // SWIG
 203
 204 typedef long long pts_t;
 205
 206         /* the reason we have the servicereference as additional argument is
 207            that we don't have to create one object for every entry in a possibly
 208            large list, provided that no state information is nessesary to deliver
 209            the required information. Anyway - ref *must* be the same as the argument
 210            to the info() or getIServiceInformation call! */
 211
 212         /* About the usage of SWIG_VOID:
 213            SWIG_VOID(real_returntype_t) hides a return value from swig. This is used for
 214            the "superflouus" RESULT return values.
 215
 216            Python code has to check the returned pointer against 0. This works,
 217            as all functions returning instances in smartpointers AND having a
 218            RESULT have to BOTH return non-zero AND set the pointer to zero.
 219
 220            Python code thus can't check for the reason, but the reason isn't
 221            user-servicable anyway. If you want to return a real reason which
 222            goes beyong "it just doesn't work", use extra variables for this,
 223            not the RESULT.
 224
 225            Hide the result only if there is another way to check for failure! */
 226
 227 class eServiceEvent;
 228
 229 SWIG_IGNORE(iStaticServiceInformation);
 230 class iStaticServiceInformation: public iObject
 231 {
 232 #ifdef SWIG
 233         iStaticServiceInformation();
 234         ~iStaticServiceInformation();
 235 #endif
 236 public:
 237         virtual SWIG_VOID(RESULT) getName(const eServiceReference &ref, std::string &SWIG_OUTPUT)=0;
 238
 239                 // doesn't need to be implemented, should return -1 then.
 240         virtual int getLength(const eServiceReference &ref);
 241         virtual SWIG_VOID(RESULT) getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time=-1);
 242                 // returns true when not implemented
 243         virtual int isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate=false);
 244
 245         virtual int getInfo(const eServiceReference &ref, int w);
 246         virtual std::string getInfoString(const eServiceReference &ref,int w);
 247         virtual PyObject *getInfoObject(const eServiceReference &ref, int w);
 248
 249         virtual int setInfo(const eServiceReference &ref, int w, int v);
 250         virtual int setInfoString(const eServiceReference &ref, int w, const char *v);
 251 };
 252 SWIG_TEMPLATE_TYPEDEF(ePtr<iStaticServiceInformation>, iStaticServiceInformationPtr);
 253
 254 class iServiceInformation_ENUMS
 255 {
 256 #ifdef SWIG
 257         iServiceInformation_ENUMS();
 258         ~iServiceInformation_ENUMS();
 259 #endif
 260 public:
 261         enum {
 262                 sIsCrypted,             /* is encrypted (no indication if decrypt was possible) */
 263                 sAspect,                /* aspect ratio: 0=4:3, 1=16:9, 2=whatever we need */
 264                 sFrameRate,                     /* frame rate */
 265                 sProgressive,           /* 0 = interlaced, 1 = progressive */
 266                 sIsMultichannel,        /* multichannel *available* (probably not selected) */
 267
 268                         /* "user serviceable info" - they are not reliable. Don't use them for anything except the service menu!
 269                            that's also the reason why they are so globally defined.
 270                            again - if somebody EVER tries to use this information for anything else than simply displaying it,
 271                            i will change this to return a user-readable text like "zero x zero three three" (and change the
 272                            exact spelling in every version) to stop that! */
 273
 274                 sVideoPID,
 275                 sAudioPID,
 276                 sPCRPID,
 277                 sPMTPID,
 278                 sTXTPID,
 279
 280                 sSID,
 281                 sONID,
 282                 sTSID,
 283                 sNamespace,
 284                 sProvider,
 285
 286                 sDescription,
 287                 sServiceref,
 288                 sTimeCreate,            /* unix time or string */
 289                 sFileSize,
 290
 291                 sCAIDs,
 292                 sVideoType,             /* MPEG2 MPEG4 */
 293
 294                 sTags,                          /* space seperated list of tags */
 295
 296                 sDVBState,                      /* states as defined in pmt handler (as events there) */
 297
 298                 sVideoHeight,
 299                 sVideoWidth,
 300
 301                 sTransponderData,       /* transponderdata as python dict */
 302
 303                 sCurrentChapter,
 304                 sCurrentTitle,
 305                 sTotalChapters,
 306                 sTotalTitles,
 307
 308                 sTagTitle,
 309                 sTagTitleSortname,
 310                 sTagArtist,
 311                 sTagArtistSortname,
 312                 sTagAlbum,
 313                 sTagAlbumSortname,
 314                 sTagComposer,
 315                 sTagDate,
 316                 sTagGenre,
 317                 sTagComment,
 318                 sTagExtendedComment,
 319                 sTagTrackNumber,
 320                 sTagTrackCount,
 321                 sTagAlbumVolumeNumber,
 322                 sTagAlbumVolumeCount,
 323                 sTagLocation,
 324                 sTagHomepage,
 325                 sTagDescription,
 326                 sTagVersion,
 327                 sTagISRC,
 328                 sTagOrganization,
 329                 sTagCopyright,
 330                 sTagCopyrightURI,
 331                 sTagContact,
 332                 sTagLicense,
 333                 sTagLicenseURI,
 334                 sTagPerformer,
 335                 sTagCodec,
 336                 sTagVideoCodec,
 337                 sTagAudioCodec,
 338                 sTagBitrate,
 339                 sTagNominalBitrate,
 340                 sTagMinimumBitrate,
 341                 sTagMaximumBitrate,
 342                 sTagSerial,
 343                 sTagEncoder,
 344                 sTagEncoderVersion,
 345                 sTagTrackGain,
 346                 sTagTrackPeak,
 347                 sTagAlbumGain,
 348                 sTagAlbumPeak,
 349                 sTagReferenceLevel,
 350                 sTagLanguageCode,
 351                 sTagImage,
 352                 sTagPreviewImage,
 353                 sTagAttachment,
 354                 sTagBeatsPerMinute,
 355                 sTagKeywords,
 356                 sTagCRC,
 357                 sTagChannelMode,
 358
 359                 sUser = 0x100
 360         };
 361         enum {
 362                 resNA = -1,
 363                 resIsString = -2,
 364                 resIsPyObject = -3
 365         };
 366 };
 367
 368 /* some words to structs like struct iServiceInformation_ENUMS
 369 For some classes we need in python just the SmartPointer Variants.
 370 So we prevent building wrapper classes for the non smart pointer classes with the SWIG_IGNORE makro.
 371 But now we have the problem that swig do not export enums for smart pointer classes (i dont know why).
 372 So we move all enum's to own classes (with _ENUMS as name ending) and let our real
 373 class inherit from the *_ENUMS class. This *_ENUMS classes are normally exportet via swig to python.
 374 But in the python code we doesn't like to write iServiceInformation_ENUMS.sVideoType....
 375 we like to write iServiceInformation.sVideoType.
 376 So until swig have no Solution for this Problem we call in lib/python/Makefile.am a python script named
 377 enigma_py_patcher.py to remove the "_ENUMS" strings in enigma.py at all needed locations. */
 378
 379 SWIG_IGNORE(iServiceInformation);
 380 class iServiceInformation: public iServiceInformation_ENUMS, public iObject
 381 {
 382 #ifdef SWIG
 383         iServiceInformation();
 384         ~iServiceInformation();
 385 #endif
 386 public:
 387         virtual SWIG_VOID(RESULT) getName(std::string &SWIG_OUTPUT)=0;
 388         virtual SWIG_VOID(RESULT) getEvent(ePtr<eServiceEvent> &SWIG_OUTPUT, int nownext);
 389
 390         virtual int getInfo(int w);
 391         virtual std::string getInfoString(int w);
 392         virtual PyObject *getInfoObject(int w);
 393
 394         virtual int setInfo(int w, int v);
 395         virtual int setInfoString(int w, const char *v);
 396 };
 397 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceInformation>, iServiceInformationPtr);
 398
 399 class iFrontendInformation_ENUMS
 400 {
 401 #ifdef SWIG
 402         iFrontendInformation_ENUMS();
 403         ~iFrontendInformation_ENUMS();
 404 #endif
 405 public:
 406         enum {
 407                 bitErrorRate,
 408                 signalPower,
 409                 signalQuality,
 410                 lockState,
 411                 syncState,
 412                 frontendNumber,
 413                 signalQualitydB,
 414         };
 415 };
 416
 417 SWIG_IGNORE(iFrontendInformation);
 418 class iFrontendInformation: public iFrontendInformation_ENUMS, public iObject
 419 {
 420 #ifdef SWIG
 421         iFrontendInformation();
 422         ~iFrontendInformation();
 423 #endif
 424 public:
 425         virtual int getFrontendInfo(int w)=0;
 426         virtual PyObject *getFrontendData()=0;
 427         virtual PyObject *getFrontendStatus()=0;
 428         virtual PyObject *getTransponderData(bool original)=0;
 429         virtual PyObject *getAll(bool original)=0; // a sum of getFrontendData/Status/TransponderData
 430 };
 431 SWIG_TEMPLATE_TYPEDEF(ePtr<iFrontendInformation>, iFrontendInformationPtr);
 432
 433 SWIG_IGNORE(iPauseableService);
 434 class iPauseableService: public iObject
 435 {
 436 #ifdef SWIG
 437         iPausableService();
 438         ~iPausableService();
 439 #endif
 440 public:
 441
 442                 /* this will set the *state* directly. So just call a SINGLE function of those at a time. */
 443         virtual RESULT pause()=0;
 444         virtual RESULT unpause()=0;
 445
 446                 /* hm. */
 447         virtual RESULT setSlowMotion(int ratio=0)=0;
 448         virtual RESULT setFastForward(int ratio=0)=0;
 449 };
 450 SWIG_TEMPLATE_TYPEDEF(ePtr<iPauseableService>, iPauseableServicePtr);
 451
 452 class iSeekableService_ENUMS
 453 {
 454 #ifdef SWIG
 455         iSeekableService_ENUMS();
 456         ~iSeekableService_ENUMS();
 457 #endif
 458 public:
 459         enum { dirForward = +1, dirBackward = -1 };
 460 };
 461
 462 SWIG_IGNORE(iSeekableService);
 463 class iSeekableService: public iSeekableService_ENUMS, public iObject
 464 {
 465 #ifdef SWIG
 466         iSeekableService();
 467         ~iSeekableService();
 468 #endif
 469 public:
 470         virtual RESULT getLength(pts_t &SWIG_OUTPUT)=0;
 471         virtual RESULT seekTo(pts_t to)=0;
 472         virtual RESULT seekRelative(int direction, pts_t to)=0;
 473         virtual RESULT getPlayPosition(pts_t &SWIG_OUTPUT)=0;
 474                 /* if you want to do several seeks in a row, you can enable the trickmode.
 475                    audio will be switched off, sync will be disabled etc. */
 476         virtual RESULT setTrickmode(int trick=0)=0;
 477         virtual RESULT isCurrentlySeekable()=0;
 478         virtual RESULT seekChapter(int) { return -1; }
 479         virtual RESULT seekTitle(int) { return -1; }
 480 };
 481 SWIG_TEMPLATE_TYPEDEF(ePtr<iSeekableService>, iSeekableServicePtr);
 482
 483 struct iAudioTrackInfo
 484 {
 485 #ifndef SWIG
 486         std::string m_description;
 487         std::string m_language; /* iso639 */
 488         int m_pid; /* for association with the stream. */
 489 #endif
 490         std::string getDescription() { return m_description; }
 491         std::string getLanguage() { return m_language; }
 492         int getPID() { return m_pid; }
 493 };
 494 SWIG_ALLOW_OUTPUT_SIMPLE(iAudioTrackInfo);
 495
 496 SWIG_IGNORE(iAudioTrackSelection);
 497 class iAudioTrackSelection: public iObject
 498 {
 499 #ifdef SWIG
 500         iAudioTrackSelection();
 501         ~iAudioTrackSelection();
 502 #endif
 503 public:
 504         virtual int getNumberOfTracks()=0;
 505         virtual RESULT selectTrack(unsigned int i)=0;
 506         virtual SWIG_VOID(RESULT) getTrackInfo(struct iAudioTrackInfo &SWIG_OUTPUT, unsigned int n)=0;
 507         virtual int getCurrentTrack()=0;
 508 };
 509 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioTrackSelection>, iAudioTrackSelectionPtr);
 510
 511 class iAudioChannelSelection_ENUMS
 512 {
 513 #ifdef SWIG
 514         iAudioChannelSelection_ENUMS();
 515         ~iAudioChannelSelection_ENUMS();
 516 #endif
 517 public:
 518         enum { LEFT, STEREO, RIGHT };
 519 };
 520
 521 SWIG_IGNORE(iAudioChannelSelection);
 522 class iAudioChannelSelection: public iAudioChannelSelection_ENUMS, public iObject
 523 {
 524 #ifdef SWIG
 525         iAudioChannelSelection();
 526         ~iAudioChannelSelection();
 527 #endif
 528 public:
 529         virtual int getCurrentChannel()=0;
 530         virtual RESULT selectChannel(int i)=0;
 531 };
 532 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioChannelSelection>, iAudioChannelSelectionPtr);
 533
 534 SWIG_IGNORE(iAudioDelay);
 535 class iAudioDelay: public iObject
 536 {
 537 #ifdef SWIG
 538         iAudioDelay();
 539         ~iAudioDelay();
 540 #endif
 541 public:
 542         virtual int getAC3Delay()=0;
 543         virtual int getPCMDelay()=0;
 544         virtual void setAC3Delay(int)=0;
 545         virtual void setPCMDelay(int)=0;
 546 };
 547 SWIG_TEMPLATE_TYPEDEF(ePtr<iAudioDelay>, iAudioDelayPtr);
 548
 549 class iRdsDecoder_ENUMS
 550 {
 551 #ifdef SWIG
 552         iRdsDecoder_ENUMS();
 553         ~iRdsDecoder_ENUMS();
 554 #endif
 555 public:
 556         enum { RadioText, RtpText };
 557 };
 558
 559 SWIG_IGNORE(iRdsDecoder);
 560 class iRdsDecoder: public iObject, public iRdsDecoder_ENUMS
 561 {
 562 #ifdef SWIG
 563         iRdsDecoder();
 564         ~iRdsDecoder();
 565 #endif
 566 public:
 567         virtual std::string getText(int x=RadioText)=0;
 568         virtual void showRassSlidePicture()=0;
 569         virtual void showRassInteractivePic(int page, int subpage)=0;
 570         virtual SWIG_PYOBJECT(ePyObject) getRassInteractiveMask()=0;
 571 };
 572 SWIG_TEMPLATE_TYPEDEF(ePtr<iRdsDecoder>, iRdsDecoderPtr);
 573
 574 SWIG_IGNORE(iSubserviceList);
 575 class iSubserviceList: public iObject
 576 {
 577 #ifdef SWIG
 578         iSubserviceList();
 579         ~iSubserviceList();
 580 #endif
 581 public:
 582         virtual int getNumberOfSubservices()=0;
 583         virtual SWIG_VOID(RESULT) getSubservice(eServiceReference &SWIG_OUTPUT, unsigned int n)=0;
 584 };
 585 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubserviceList>, iSubserviceListPtr);
 586
 587 SWIG_IGNORE(iTimeshiftService);
 588 class iTimeshiftService: public iObject
 589 {
 590 #ifdef SWIG
 591         iTimeshiftService();
 592         ~iTimeshiftService();
 593 #endif
 594 public:
 595         virtual RESULT startTimeshift()=0;
 596         virtual RESULT stopTimeshift(bool swToLive=true)=0;
 597         virtual RESULT setNextPlaybackFile(const char *fn)=0; // not needed by our internal timeshift.. but external plugin...
 598
 599         virtual int isTimeshiftActive()=0;
 600                         /* this essentially seeks to the relative end of the timeshift buffer */
 601         virtual RESULT activateTimeshift()=0;
 602 };
 603 SWIG_TEMPLATE_TYPEDEF(ePtr<iTimeshiftService>, iTimeshiftServicePtr);
 604
 605         /* not related to eCueSheet */
 606
 607 class iCueSheet_ENUMS
 608 {
 609 #ifdef SWIG
 610         iCueSheet_ENUMS();
 611         ~iCueSheet_ENUMS();
 612 #endif
 613 public:
 614         enum { cutIn = 0, cutOut = 1, cutMark = 2 };
 615 };
 616
 617 SWIG_IGNORE(iCueSheet);
 618 class iCueSheet: public iCueSheet_ENUMS, public iObject
 619 {
 620 #ifdef SWIG
 621         iCueSheet();
 622         ~iCueSheet();
 623 #endif
 624 public:
 625         /* returns a list of (pts, what)-tuples */
 626         virtual PyObject *getCutList() = 0;
 627         virtual void setCutList(SWIG_PYOBJECT(ePyObject) list) = 0;
 628         virtual void setCutListEnable(int enable) = 0;
 629 };
 630 SWIG_TEMPLATE_TYPEDEF(ePtr<iCueSheet>, iCueSheetPtr);
 631
 632 class eWidget;
 633 class PyList;
 634
 635 SWIG_IGNORE(iSubtitleOutput);
 636 class iSubtitleOutput: public iObject
 637 {
 638 public:
 639         virtual RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry)=0;
 640         virtual RESULT disableSubtitles(eWidget *parent)=0;
 641         virtual PyObject *getSubtitleList()=0;
 642         virtual PyObject *getCachedSubtitle()=0;
 643 };
 644 SWIG_TEMPLATE_TYPEDEF(ePtr<iSubtitleOutput>, iSubtitleOutputPtr);
 645
 646 SWIG_IGNORE(iMutableServiceList);
 647 class iMutableServiceList: public iObject
 648 {
 649 #ifdef SWIG
 650         iMutableServiceList();
 651         ~iMutableServiceList();
 652 #endif
 653 public:
 654                 /* flush changes */
 655         virtual RESULT flushChanges()=0;
 656                 /* adds a service to a list */
 657         virtual RESULT addService(eServiceReference &ref, eServiceReference before=eServiceReference())=0;
 658                 /* removes a service from a list */
 659         virtual RESULT removeService(eServiceReference &ref)=0;
 660                 /* moves a service in a list, only if list suppports a specific sort method. */
 661                 /* pos is the new, absolute position from 0..size-1 */
 662         virtual RESULT moveService(eServiceReference &ref, int pos)=0;
 663                 /* set name of list, for bouquets this is the visible bouquet name */
 664         virtual RESULT setListName(const std::string &name)=0;
 665 };
 666 SWIG_TEMPLATE_TYPEDEF(ePtr<iMutableServiceList>, iMutableServiceListPtr);
 667
 668 SWIG_IGNORE(iListableService);
 669 class iListableService: public iObject
 670 {
 671 #ifdef SWIG
 672         iListableService();
 673         ~iListableService();
 674 #endif
 675 public:
 676 #ifndef SWIG
 677                 /* legacy interface: get a list */
 678         virtual RESULT getContent(std::list<eServiceReference> &list, bool sorted=false)=0;
 679 #endif
 680         virtual PyObject *getContent(const char* format, bool sorted=false)=0;
 681
 682                 /* new, shiny interface: streaming. */
 683         virtual SWIG_VOID(RESULT) getNext(eServiceReference &SWIG_OUTPUT)=0;
 684
 685                 /* use this for sorting. output is not sorted because of either
 686                  - performance reasons: the whole list must be buffered or
 687                  - the interface would be restricted to a list. streaming
 688                    (as well as a future "active" extension) won't be possible.
 689                 */
 690         virtual int compareLessEqual(const eServiceReference &, const eServiceReference &)=0;
 691
 692         virtual SWIG_VOID(RESULT) startEdit(ePtr<iMutableServiceList> &SWIG_OUTPUT)=0;
 693 };
 694 SWIG_TEMPLATE_TYPEDEF(ePtr<iListableService>, iListableServicePtr);
 695
 696 #ifndef SWIG
 697         /* a helper class which can be used as argument to stl's sort(). */
 698 class iListableServiceCompare
 699 {
 700         ePtr<iListableService> m_list;
 701 public:
 702         iListableServiceCompare(iListableService *list): m_list(list) { }
 703         bool operator()(const eServiceReference &a, const eServiceReference &b)
 704         {
 705                 return m_list->compareLessEqual(a, b);
 706         }
 707 };
 708 #endif
 709
 710 SWIG_IGNORE(iServiceOfflineOperations);
 711 class iServiceOfflineOperations: public iObject
 712 {
 713 #ifdef SWIG
 714         iServiceOfflineOperations();
 715         ~iServiceOfflineOperations();
 716 #endif
 717 public:
 718                 /* to delete a service, forever. */
 719         virtual RESULT deleteFromDisk(int simulate=1)=0;
 720
 721                 /* for transferring a service... */
 722         virtual SWIG_VOID(RESULT) getListOfFilenames(std::list<std::string> &SWIG_OUTPUT)=0;
 723
 724                 /* a blocking call to reindex a file */
 725         virtual int reindex() = 0;
 726
 727                 // TODO: additional stuff, like a conversion interface?
 728 };
 729 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceOfflineOperations>, iServiceOfflineOperationsPtr);
 730
 731 SWIG_IGNORE(iStreamableService);
 732 class iStreamableService: public iObject
 733 {
 734 #ifdef SWIG
 735         iStreamableService();
 736         ~iStreamableService();
 737 #endif
 738 public:
 739                 /* returns a dict:
 740                         { "demux": <n>,
 741                           "pids": [(x,type),(y,type),(z,type),..],
 742                           ...
 743                         }
 744                         with type being "video", "audio", "pmt", "pat"...
 745                 */
 746         virtual PyObject *getStreamingData()=0;
 747 };
 748 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamableService>, iStreamableServicePtr);
 749
 750 SWIG_IGNORE(iStreamedService);
 751 class iStreamedService: public iObject
 752 {
 753 #ifdef SWIG
 754         iStreamedService();
 755         ~iStreamedService();
 756 #endif
 757 public:
 758         virtual PyObject *getBufferCharge()=0;
 759         virtual int setBufferSize(int size)=0;
 760 };
 761 SWIG_TEMPLATE_TYPEDEF(ePtr<iStreamedService>, iStreamedServicePtr);
 762
 763 class iServiceKeys_ENUMS
 764 {
 765 #ifdef SWIG
 766         iServiceKeys_ENUMS();
 767         ~iServiceKeys_ENUMS();
 768 #endif
 769 public:
 770         enum {
 771                 keyLeft,
 772                 keyRight,
 773                 keyUp,
 774                 keyDown,
 775                 keyOk,
 776                 keyUser = 0x100
 777         };
 778 };
 779
 780 SWIG_IGNORE(iServiceKeys);
 781 class iServiceKeys: public iServiceKeys_ENUMS, public iObject
 782 {
 783 #ifdef SWIG
 784         iServiceKeys();
 785         ~iServiceKeys();
 786 #endif
 787 public:
 788         virtual SWIG_VOID(RESULT) keyPressed(int key)=0;
 789 };
 790 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceKeys>, iServiceKeysPtr);
 791
 792 class iPlayableService_ENUMS
 793 {
 794 #ifdef SWIG
 795         iPlayableService_ENUMS();
 796         ~iPlayableService_ENUMS();
 797 #endif
 798 public:
 799         enum {
 800                         /* these first two events are magical, and should only
 801                            be generated if you know what you're doing. */
 802                 evStart,
 803                 evEnd,
 804
 805                 evTunedIn,
 806                 evTuneFailed,
 807
 808                         /* when iServiceInformation is implemented:*/
 809                 evUpdatedEventInfo,
 810                 evUpdatedInfo,
 811
 812                         /* when seek() is implemented: */
 813                 evSeekableStatusChanged, /* for example when timeshifting */
 814
 815                 evEOF,
 816                 evSOF, /* bounced against start of file (when seeking backwards) */
 817
 818                         /* when cueSheet is implemented */
 819                 evCuesheetChanged,
 820
 821                         /* when rdsDecoder is implemented */
 822                 evUpdatedRadioText,
 823                 evUpdatedRtpText,
 824
 825                         /* Radio Screenshow Support */
 826                 evUpdatedRassSlidePic,
 827                 evUpdatedRassInteractivePicMask,
 828
 829                 evVideoSizeChanged,
 830                 evVideoFramerateChanged,
 831                 evVideoProgressiveChanged,
 832
 833                 evBuffering,
 834
 835                 evStopped,
 836
 837                 evUser = 0x100
 838         };
 839 };
 840
 841 SWIG_IGNORE(iPlayableService);
 842 class iPlayableService: public iPlayableService_ENUMS, public iObject
 843 {
 844 #ifdef SWIG
 845         iPlayableService();
 846         ~iPlaybleService();
 847 #endif
 848         friend class iServiceHandler;
 849 public:
 850 #ifndef SWIG
 851         virtual RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)=0;
 852 #endif
 853         virtual RESULT start()=0;
 854         virtual RESULT stop()=0;
 855                         /* might have to be changed... */
 856         virtual RESULT setTarget(int target)=0;
 857         virtual SWIG_VOID(RESULT) seek(ePtr<iSeekableService> &SWIG_OUTPUT)=0;
 858         virtual SWIG_VOID(RESULT) pause(ePtr<iPauseableService> &SWIG_OUTPUT)=0;
 859         virtual SWIG_VOID(RESULT) info(ePtr<iServiceInformation> &SWIG_OUTPUT)=0;
 860         virtual SWIG_VOID(RESULT) audioTracks(ePtr<iAudioTrackSelection> &SWIG_OUTPUT)=0;
 861         virtual SWIG_VOID(RESULT) audioChannel(ePtr<iAudioChannelSelection> &SWIG_OUTPUT)=0;
 862         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 863         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 864         virtual SWIG_VOID(RESULT) timeshift(ePtr<iTimeshiftService> &SWIG_OUTPUT)=0;
 865         virtual SWIG_VOID(RESULT) cueSheet(ePtr<iCueSheet> &SWIG_OUTPUT)=0;
 866         virtual SWIG_VOID(RESULT) subtitle(ePtr<iSubtitleOutput> &SWIG_OUTPUT)=0;
 867         virtual SWIG_VOID(RESULT) audioDelay(ePtr<iAudioDelay> &SWIG_OUTPUT)=0;
 868         virtual SWIG_VOID(RESULT) rdsDecoder(ePtr<iRdsDecoder> &SWIG_OUTPUT)=0;
 869         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 870         virtual SWIG_VOID(RESULT) streamed(ePtr<iStreamedService> &SWIG_OUTPUT)=0;
 871         virtual SWIG_VOID(RESULT) keys(ePtr<iServiceKeys> &SWIG_OUTPUT)=0;
 872 };
 873 SWIG_TEMPLATE_TYPEDEF(ePtr<iPlayableService>, iPlayableServicePtr);
 874
 875 class iRecordableService_ENUMS
 876 {
 877 #ifdef SWIG
 878         iRecordableService_ENUMS();
 879         ~iRecordableService_ENUMS();
 880 #endif
 881 public:
 882         enum {
 883                 evStart,
 884                 evEnd,
 885                 evTunedIn,
 886                 evTuneFailed,
 887                 evRecordRunning,
 888                 evRecordStopped,
 889                 evNewProgramInfo,
 890                 evRecordFailed,
 891                 evRecordWriteError,
 892                 evNewEventInfo
 893         };
 894         enum {
 895                 NoError=0,
 896                 errOpenRecordFile=-1,
 897                 errNoDemuxAvailable=-2,
 898                 errNoTsRecorderAvailable=-3,
 899                 errDiskFull=-4,
 900                 errTuneFailed=-255,
 901                 errMisconfiguration = -256,
 902                 errNoResources = -257,
 903         };
 904 };
 905
 906 SWIG_IGNORE(iRecordableService);
 907 class iRecordableService: public iRecordableService_ENUMS, public iObject
 908 {
 909 #ifdef SWIG
 910         iRecordableService();
 911         ~iRecordableService();
 912 #endif
 913 public:
 914 #ifndef SWIG
 915         virtual RESULT connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)=0;
 916 #endif
 917         virtual SWIG_VOID(RESULT) getError(int &SWIG_OUTPUT)=0;
 918         virtual RESULT prepare(const char *filename, time_t begTime=-1, time_t endTime=-1, int eit_event_id=-1, const char *name=0, const char *descr=0, const char *tags=0)=0;
 919         virtual RESULT prepareStreaming()=0;
 920         virtual RESULT start(bool simulate=false)=0;
 921         virtual RESULT stop()=0;
 922         virtual SWIG_VOID(RESULT) frontendInfo(ePtr<iFrontendInformation> &SWIG_OUTPUT)=0;
 923         virtual SWIG_VOID(RESULT) stream(ePtr<iStreamableService> &SWIG_OUTPUT)=0;
 924         virtual SWIG_VOID(RESULT) subServices(ePtr<iSubserviceList> &SWIG_OUTPUT)=0;
 925 };
 926 SWIG_TEMPLATE_TYPEDEF(ePtr<iRecordableService>, iRecordableServicePtr);
 927
 928 extern PyObject *New_iRecordableServicePtr(const ePtr<iRecordableService> &ref); // defined in enigma_python.i
 929
 930 inline PyObject *PyFrom(ePtr<iRecordableService> &c)
 931 {
 932         return New_iRecordableServicePtr(c);
 933 }
 934
 935 #ifndef SWIG
 936 #ifdef PYTHON_REFCOUNT_DEBUG
 937 inline ePyObject Impl_New_iRecordableServicePtr(const char* file, int line, const ePtr<iRecordableService> &ptr)
 938 {
 939         return ePyObject(New_iRecordableServicePtr(ptr), file, line);
 940 }
 941 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(__FILE__, __LINE__, ptr)
 942 #else
 943 inline ePyObject Impl_New_iRecordableServicePtr(const ePtr<iRecordableService> &ptr)
 944 {
 945         return New_iRecordableServicePtr(ptr);
 946 }
 947 #define NEW_iRecordableServicePtr(ptr) Impl_New_iRecordableServicePtr(ptr)
 948 #endif
 949 #endif // SWIG
 950
 951 SWIG_IGNORE(iServiceHandler);
 952 class iServiceHandler: public iObject
 953 {
 954 #ifdef SWIG
 955         iServiceHandler();
 956         ~iServiceHandler();
 957 #endif
 958 public:
 959         virtual SWIG_VOID(RESULT) play(const eServiceReference &, ePtr<iPlayableService> &SWIG_OUTPUT)=0;
 960         virtual SWIG_VOID(RESULT) record(const eServiceReference &, ePtr<iRecordableService> &SWIG_OUTPUT)=0;
 961         virtual SWIG_VOID(RESULT) list(const eServiceReference &, ePtr<iListableService> &SWIG_OUTPUT)=0;
 962         virtual SWIG_VOID(RESULT) info(const eServiceReference &, ePtr<iStaticServiceInformation> &SWIG_OUTPUT)=0;
 963         virtual SWIG_VOID(RESULT) offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &SWIG_OUTPUT)=0;
 964 };
 965 SWIG_TEMPLATE_TYPEDEF(ePtr<iServiceHandler>, iServiceHandlerPtr);
 966
 967 #endif