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