code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/idvb.h

   1 #ifndef __dvb_idvb_h
   2 #define __dvb_idvb_h
   3
   4 #ifndef SWIG
   5
   6 #if HAVE_DVB_API_VERSION < 3
   7 #include <ost/frontend.h>
   8 #define FRONTENDPARAMETERS FrontendParameters
   9 #else
  10 #include <linux/dvb/frontend.h>
  11 #include <linux/dvb/video.h>
  12 #define FRONTENDPARAMETERS struct dvb_frontend_parameters
  13 #endif
  14 #include <lib/dvb/frontendparms.h>
  15 #include <lib/base/object.h>
  16 #include <lib/base/ebase.h>
  17 #include <lib/base/elock.h>
  18 #include <lib/service/service.h>
  19 #include <libsig_comp.h>
  20 #include <connection.h>
  21
  22 #if defined(__GNUC__) && ((__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || __GNUC__ == 4 )  // check if gcc version >= 3.1
  23 #include <ext/slist>
  24 #define CAID_LIST __gnu_cxx::slist<uint16_t>
  25 #else
  26 #include <slist>
  27 #define CAID_LIST std::slist<uint16_t>
  28 #endif
  29
  30 #ifndef DMX_FILTER_SIZE
  31 #define DMX_FILTER_SIZE   16
  32 #endif
  33
  34 struct eDVBSectionFilterMask
  35 {
  36         int pid;
  37                 /* mode is 0 for positive, 1 for negative filtering */
  38         __u8 data[DMX_FILTER_SIZE], mask[DMX_FILTER_SIZE], mode[DMX_FILTER_SIZE];
  39         enum {
  40                 rfCRC=1,
  41                 rfNoAbort=2
  42         };
  43         int flags;
  44 };
  45
  46 struct eDVBTableSpec
  47 {
  48         int pid, tid, tidext, tid_mask, tidext_mask;
  49         int version;
  50         int timeout;        /* timeout in ms */
  51         enum
  52         {
  53                 tfInOrder=1,
  54                 /*
  55                         tfAnyVersion      filter ANY version
  56                         0                 filter all EXCEPT given version (negative filtering)
  57                         tfThisVersion     filter only THIS version
  58                 */
  59                 tfAnyVersion=2,
  60                 tfThisVersion=4,
  61                 tfHaveTID=8,
  62                 tfHaveTIDExt=16,
  63                 tfCheckCRC=32,
  64                 tfHaveTimeout=64,
  65                 tfHaveTIDMask=128,
  66                 tfHaveTIDExtMask=256
  67         };
  68         int flags;
  69 };
  70
  71 struct eBouquet
  72 {
  73         std::string m_bouquet_name;
  74         std::string m_filename;  // without path.. just name
  75         typedef std::list<eServiceReference> list;
  76         list m_services;
  77 // the following five methods are implemented in db.cpp
  78         RESULT flushChanges();
  79         RESULT addService(const eServiceReference &, eServiceReference before=eServiceReference());
  80         RESULT removeService(const eServiceReference &);
  81         RESULT moveService(const eServiceReference &, unsigned int);
  82         RESULT setListName(const std::string &name);
  83 };
  84
  85                 /* these structures have by intention no operator int() defined.
  86                    the reason of these structures is to avoid mixing for example
  87                    a onid and a tsid (as there's no general order for them).
  88
  89                    defining an operator int() would implicitely convert values
  90                    between them over the constructor with the int argument.
  91
  92                    'explicit' doesn't here - eTransportStreamID(eOriginalNetworkID(n))
  93                    would still work. */
  94
  95 struct eTransportStreamID
  96 {
  97 private:
  98         int v;
  99 public:
 100         int get() const { return v; }
 101         eTransportStreamID(int i): v(i) { }
 102         eTransportStreamID(): v(-1) { }
 103         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
 104         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
 105         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
 106         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
 107 };
 108
 109 struct eServiceID
 110 {
 111 private:
 112         int v;
 113 public:
 114         int get() const { return v; }
 115         eServiceID(int i): v(i) { }
 116         eServiceID(): v(-1) { }
 117         bool operator == (const eServiceID &c) const { return v == c.v; }
 118         bool operator != (const eServiceID &c) const { return v != c.v; }
 119         bool operator < (const eServiceID &c) const { return v < c.v; }
 120         bool operator > (const eServiceID &c) const { return v > c.v; }
 121 };
 122
 123 struct eOriginalNetworkID
 124 {
 125 private:
 126         int v;
 127 public:
 128         int get() const { return v; }
 129         eOriginalNetworkID(int i): v(i) { }
 130         eOriginalNetworkID(): v(-1) { }
 131         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
 132         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
 133         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
 134         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
 135 };
 136
 137 struct eDVBNamespace
 138 {
 139 private:
 140         int v;
 141 public:
 142         int get() const { return v; }
 143         eDVBNamespace(int i): v(i) { }
 144         eDVBNamespace(): v(-1) { }
 145         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
 146         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
 147         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
 148         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
 149 };
 150
 151 struct eDVBChannelID
 152 {
 153         eDVBNamespace dvbnamespace;
 154         eTransportStreamID transport_stream_id;
 155         eOriginalNetworkID original_network_id;
 156
 157         bool operator==(const eDVBChannelID &c) const
 158         {
 159                 return dvbnamespace == c.dvbnamespace &&
 160                         transport_stream_id == c.transport_stream_id &&
 161                         original_network_id == c.original_network_id;
 162         }
 163
 164         bool operator<(const eDVBChannelID &c) const
 165         {
 166                 if (dvbnamespace < c.dvbnamespace)
 167                         return 1;
 168                 else if (dvbnamespace == c.dvbnamespace)
 169                 {
 170                         if (original_network_id < c.original_network_id)
 171                                 return 1;
 172                         else if (original_network_id == c.original_network_id)
 173                                 if (transport_stream_id < c.transport_stream_id)
 174                                         return 1;
 175                 }
 176                 return 0;
 177         }
 178         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid):
 179                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
 180         {
 181         }
 182         eDVBChannelID():
 183                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
 184         {
 185         }
 186         operator bool() const
 187         {
 188                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
 189         }
 190 };
 191
 192 struct eServiceReferenceDVB: public eServiceReference
 193 {
 194         int getServiceType() const { return data[0]; }
 195         void setServiceType(int service_type) { data[0]=service_type; }
 196
 197         eServiceID getServiceID() const { return eServiceID(data[1]); }
 198         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
 199
 200         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
 201         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
 202
 203         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
 204         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
 205
 206         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
 207         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
 208
 209         eServiceID getParentServiceID() const { return eServiceID(data[5]); }
 210         void setParentServiceID( eServiceID sid ) { data[5]=sid.get(); }
 211
 212         eTransportStreamID getParentTransportStreamID() const { return eTransportStreamID(data[6]); }
 213         void setParentTransportStreamID( eTransportStreamID tsid ) { data[6]=tsid.get(); }
 214
 215         eServiceReferenceDVB getParentServiceReference() const
 216         {
 217                 eServiceReferenceDVB tmp(*this);
 218                 if (data[5] && data[6])
 219                 {
 220                         tmp.data[1] = data[5];
 221                         tmp.data[2] = data[6];
 222                         tmp.data[5] = tmp.data[6] = 0;
 223                 }
 224                 else
 225                         tmp.type = idInvalid;
 226                 return tmp;
 227         }
 228
 229         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 230                 :eServiceReference(eServiceReference::idDVB, 0)
 231         {
 232                 setTransportStreamID(transport_stream_id);
 233                 setOriginalNetworkID(original_network_id);
 234                 setDVBNamespace(dvbnamespace);
 235                 setServiceID(service_id);
 236                 setServiceType(service_type);
 237         }
 238
 239         void set(const eDVBChannelID &chid)
 240         {
 241                 setDVBNamespace(chid.dvbnamespace);
 242                 setOriginalNetworkID(chid.original_network_id);
 243                 setTransportStreamID(chid.transport_stream_id);
 244         }
 245
 246         void getChannelID(eDVBChannelID &chid) const
 247         {
 248                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 249         }
 250
 251         eServiceReferenceDVB()
 252                 :eServiceReference(eServiceReference::idDVB, 0)
 253         {
 254         }
 255
 256         eServiceReferenceDVB(const std::string &string)
 257                 :eServiceReference(string)
 258         {
 259         }
 260 };
 261
 262
 263 ////////////////// TODO: we need an interface here, but what exactly?
 264
 265 #include <set>
 266 // btw, still implemented in db.cpp. FIX THIS, TOO.
 267
 268 class eDVBChannelQuery;
 269
 270 class eDVBService: public iStaticServiceInformation
 271 {
 272         DECLARE_REF(eDVBService);
 273         int *m_cache;
 274         void initCache();
 275         void copyCache(int *source);
 276 public:
 277         enum cacheID
 278         {
 279                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID,
 280                 cVTYPE, cACHANNEL, cAC3DELAY, cPCMDELAY,
 281                 cSUBTITLE, cacheMax
 282         };
 283
 284         int getCacheEntry(cacheID);
 285         void setCacheEntry(cacheID, int);
 286
 287         bool cacheEmpty();
 288
 289         eDVBService();
 290                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
 291         std::string m_service_name, m_service_name_sort;
 292         std::string m_provider_name;
 293
 294         void genSortName();
 295
 296         int m_flags;
 297         enum
 298         {
 299                 dxNoSDT=1,    // don't get SDT
 300                 dxDontshow=2,
 301                 dxNoDVB=4,  // dont use PMT for this service ( use cached pids )
 302                 dxHoldName=8,
 303                 dxNewFound=64,
 304         };
 305
 306         bool usePMT() const { return !(m_flags & dxNoDVB); }
 307         bool isHidden() const { return m_flags & dxDontshow; }
 308
 309         CAID_LIST m_ca;
 310
 311         virtual ~eDVBService();
 312
 313         eDVBService &operator=(const eDVBService &);
 314
 315         // iStaticServiceInformation
 316         RESULT getName(const eServiceReference &ref, std::string &name);
 317         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 318         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate=false);
 319         PyObject *getInfoObject(const eServiceReference &ref, int);  // implemented in lib/service/servicedvb.h
 320
 321                 /* for filtering: */
 322         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 323 };
 324
 325 //////////////////
 326
 327 class iDVBChannel;
 328 class iDVBDemux;
 329 class iDVBFrontendParameters;
 330
 331 class iDVBChannelListQuery: public iObject
 332 {
 333 public:
 334         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 335         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 336 };
 337
 338 class eDVBChannelQuery: public iObject
 339 {
 340         DECLARE_REF(eDVBChannelQuery);
 341 public:
 342         enum
 343         {
 344                 tName,
 345                 tProvider,
 346                 tType,
 347                 tBouquet,
 348                 tSatellitePosition,
 349                 tChannelID,
 350                 tAND,
 351                 tOR,
 352                 tAny,
 353                 tFlags
 354         };
 355
 356         int m_type;
 357         int m_inverse;
 358
 359         std::string m_string;
 360         int m_int;
 361         eDVBChannelID m_channelid;
 362
 363                 /* sort is only valid in root, and must be from the enum above. */
 364         int m_sort;
 365         std::string m_bouquet_name;
 366
 367         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 368
 369         ePtr<eDVBChannelQuery> m_p1, m_p2;
 370 };
 371
 372 class iDVBChannelList: public iObject
 373 {
 374 public:
 375         virtual RESULT removeService(const eServiceReference &service)=0;
 376         virtual RESULT removeServices(eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0;
 377         virtual RESULT removeServices(int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0;
 378         virtual RESULT removeServices(iDVBFrontendParameters *feparm)=0;
 379         virtual RESULT addFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0;
 380         virtual RESULT removeFlag(const eServiceReference &service, unsigned int flagmask=0xFFFFFFFF)=0;
 381         virtual RESULT removeFlags(unsigned int flagmask, eDVBChannelID chid=eDVBChannelID(), unsigned int orb_pos=0xFFFFFFFF)=0;
 382         virtual RESULT removeFlags(unsigned int flagmask, int dvb_namespace=-1, int tsid=-1, int onid=-1, unsigned int orb_pos=0xFFFFFFFF)=0;
 383         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 384         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 385
 386         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 387
 388         virtual RESULT addService(const eServiceReferenceDVB &reference, eDVBService *service)=0;
 389         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 390         virtual RESULT flush()=0;
 391
 392         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 393
 394         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *q, const eServiceReference &source)=0;
 395 };
 396
 397 #endif  // SWIG
 398
 399 class iDVBFrontendParameters: public iObject
 400 {
 401 #ifdef SWIG
 402         iDVBFrontendParameters();
 403         ~iDVBFrontendParameters();
 404 #endif
 405 public:
 406         enum { flagOnlyFree = 1 };
 407         virtual SWIG_VOID(RESULT) getSystem(int &SWIG_OUTPUT) const = 0;
 408         virtual SWIG_VOID(RESULT) getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
 409         virtual SWIG_VOID(RESULT) getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
 410         virtual SWIG_VOID(RESULT) getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
 411         virtual SWIG_VOID(RESULT) getFlags(unsigned int &SWIG_OUTPUT) const = 0;
 412 #ifndef SWIG
 413         virtual SWIG_VOID(RESULT) calculateDifference(const iDVBFrontendParameters *parm, int &, bool exact) const = 0;
 414         virtual SWIG_VOID(RESULT) getHash(unsigned long &) const = 0;
 415         virtual SWIG_VOID(RESULT) calcLockTimeout(unsigned int &) const = 0;
 416 #endif
 417 };
 418 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontendParameters>, iDVBFrontendParametersPtr);
 419
 420 #define MAX_DISEQC_LENGTH  16
 421
 422 class eDVBDiseqcCommand
 423 {
 424 #ifndef SWIG
 425 public:
 426 #endif
 427         int len;
 428         __u8 data[MAX_DISEQC_LENGTH];
 429 #if HAVE_DVB_API_VERSION < 3
 430         int tone;
 431         int voltage;
 432 #endif
 433 #ifdef SWIG
 434 public:
 435 #endif
 436         void setCommandString(const char *str);
 437 };
 438
 439 class iDVBSatelliteEquipmentControl;
 440 class eSecCommandList;
 441
 442 class iDVBFrontend_ENUMS
 443 {
 444 #ifdef SWIG
 445         iDVBFrontend_ENUMS();
 446         ~iDVBFrontend_ENUMS();
 447 #endif
 448 public:
 449         enum { feSatellite, feCable, feTerrestrial };
 450         enum { stateIdle, stateTuning, stateFailed, stateLock, stateLostLock, stateClosed };
 451         enum { toneOff, toneOn };
 452         enum { voltageOff, voltage13, voltage18, voltage13_5, voltage18_5 };
 453         enum { bitErrorRate, signalPower, signalQuality, locked, synced, frontendNumber, signalQualitydB };
 454 };
 455
 456 SWIG_IGNORE(iDVBFrontend);
 457 class iDVBFrontend: public iDVBFrontend_ENUMS, public iObject
 458 {
 459 public:
 460         virtual RESULT getFrontendType(int &SWIG_OUTPUT)=0;
 461         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 462         virtual int closeFrontend(bool force = false, bool no_delayed = false)=0;
 463         virtual void reopenFrontend()=0;
 464 #ifndef SWIG
 465         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 466 #endif
 467         virtual RESULT getState(int &SWIG_OUTPUT)=0;
 468         virtual RESULT setTone(int tone)=0;
 469         virtual RESULT setVoltage(int voltage)=0;
 470         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 471         virtual RESULT sendToneburst(int burst)=0;
 472 #ifndef SWIG
 473         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 474         virtual RESULT setSecSequence(eSecCommandList &list)=0;
 475 #endif
 476         virtual int readFrontendData(int type)=0;
 477         virtual void getFrontendStatus(SWIG_PYOBJECT(ePyObject) dest)=0;
 478         virtual void getTransponderData(SWIG_PYOBJECT(ePyObject) dest, bool original)=0;
 479         virtual void getFrontendData(SWIG_PYOBJECT(ePyObject) dest)=0;
 480 #ifndef SWIG
 481         virtual RESULT getData(int num, long &data)=0;
 482         virtual RESULT setData(int num, long val)=0;
 483                 /* 0 means: not compatible. other values are a priority. */
 484         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 485 #endif
 486 };
 487 SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontend>, iDVBFrontendPtr);
 488
 489 #ifndef SWIG
 490 class iDVBSatelliteEquipmentControl: public iObject
 491 {
 492 public:
 493         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id, unsigned int timeout)=0;
 494         virtual void prepareTurnOffSatCR(iDVBFrontend &frontend, int satcr)=0;
 495         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id, int *highest_score_lnb=0)=0;
 496         virtual void setRotorMoving(int slotid, bool)=0;
 497 };
 498
 499 struct eDVBCIRouting
 500 {
 501         int enabled;
 502 };
 503 #endif // SWIG
 504
 505 SWIG_IGNORE(iDVBChannel);
 506 class iDVBChannel: public iObject
 507 {
 508 public:
 509                 /* direct frontend access for raw channels and/or status inquiries. */
 510         virtual SWIG_VOID(RESULT) getFrontend(ePtr<iDVBFrontend> &SWIG_OUTPUT)=0;
 511         virtual RESULT requestTsidOnid(SWIG_PYOBJECT(ePyObject) callback) { return -1; }
 512         virtual int reserveDemux() { return -1; }
 513 #ifndef SWIG
 514         enum
 515         {
 516                 state_idle,        /* not yet tuned */
 517                 state_tuning,      /* currently tuning (first time) */
 518                 state_failed,      /* tuning failed. */
 519                 state_unavailable, /* currently unavailable, will be back without further interaction */
 520                 state_ok,          /* ok */
 521                 state_last_instance, /* just one reference to this channel is left */
 522                 state_release      /* channel is being shut down. */
 523         };
 524         virtual RESULT getState(int &)=0;
 525
 526         virtual RESULT getCurrentFrontendParameters(ePtr<iDVBFrontendParameters> &)=0;
 527         enum
 528         {
 529                 evtPreStart, evtEOF, evtSOF, evtFailed
 530         };
 531         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 532         virtual RESULT connectEvent(const Slot2<void,iDVBChannel*,int> &eventChange, ePtr<eConnection> &connection)=0;
 533
 534                 /* demux capabilities */
 535         enum
 536         {
 537                 capDecode = 1,
 538                 /* capCI = 2 */
 539         };
 540         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 541         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 542
 543                 /* use count handling */
 544         virtual void AddUse() = 0;
 545         virtual void ReleaseUse() = 0;
 546 #endif
 547 };
 548 SWIG_TEMPLATE_TYPEDEF(eUsePtr<iDVBChannel>, iDVBChannelPtr);
 549
 550 #ifndef SWIG
 551         /* signed, so we can express deltas. */
 552
 553 typedef long long pts_t;
 554
 555 class iFilePushScatterGather;
 556 class iTSMPEGDecoder;
 557
 558         /* note that a cue sheet describes the logical positions. thus
 559            everything is specified in pts and not file positions */
 560
 561         /* implemented in dvb.cpp */
 562 class eCueSheet: public iObject, public Object
 563 {
 564         DECLARE_REF(eCueSheet);
 565 public:
 566         eCueSheet();
 567
 568                         /* frontend */
 569         void seekTo(int relative, const pts_t &pts);
 570
 571         void clear();
 572         void addSourceSpan(const pts_t &begin, const pts_t &end);
 573         void commitSpans();
 574
 575         void setSkipmode(const pts_t &ratio); /* 90000 is 1:1 */
 576         void setDecodingDemux(iDVBDemux *demux, iTSMPEGDecoder *decoder);
 577
 578                         /* frontend and backend */
 579         eRdWrLock m_lock;
 580
 581                         /* backend */
 582         enum { evtSeek, evtSkipmode, evtSpanChanged };
 583         RESULT connectEvent(const Slot1<void, int> &event, ePtr<eConnection> &connection);
 584
 585         std::list<std::pair<pts_t,pts_t> > m_spans;     /* begin, end */
 586         std::list<std::pair<int, pts_t> > m_seek_requests; /* relative, delta */
 587         pts_t m_skipmode_ratio;
 588         Signal1<void,int> m_event;
 589         ePtr<iDVBDemux> m_decoding_demux;
 590         ePtr<iTSMPEGDecoder> m_decoder;
 591 };
 592
 593 class iDVBPVRChannel: public iDVBChannel
 594 {
 595 public:
 596         enum
 597         {
 598                 state_eof = state_release + 1  /* end-of-file reached. */
 599         };
 600
 601                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 602                 /* so this is VERY UGLY.
 603
 604                    ok, it's going to get better. but still...*/
 605         virtual RESULT playFile(const char *file) = 0;
 606         virtual void stopFile() = 0;
 607
 608         virtual void setCueSheet(eCueSheet *cuesheet) = 0;
 609
 610         virtual RESULT getLength(pts_t &pts) = 0;
 611
 612                 /* we explicitely ask for the decoding demux here because a channel
 613                    can be shared between multiple decoders.
 614                 */
 615         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode) = 0;
 616                 /* skipping must be done with a cue sheet */
 617 };
 618
 619 class iDVBSectionReader;
 620 class iDVBPESReader;
 621 class iDVBTSRecorder;
 622 class iTSMPEGDecoder;
 623
 624 class iDVBDemux: public iObject
 625 {
 626 public:
 627         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 628         virtual RESULT createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader)=0;
 629         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 630         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader, int primary=1)=0;
 631         virtual RESULT getSTC(pts_t &pts, int num=0)=0;
 632         virtual RESULT getCADemuxID(uint8_t &id)=0;
 633         virtual RESULT flush()=0;
 634 };
 635
 636 #if HAVE_DVB_API_VERSION < 3 && !defined(VIDEO_EVENT_SIZE_CHANGED)
 637 #define VIDEO_EVENT_SIZE_CHANGED 1
 638 #define VIDEO_EVENT_FRAME_RATE_CHANGED 2
 639 #endif
 640
 641 class iTSMPEGDecoder: public iObject
 642 {
 643 public:
 644         enum { pidDisabled = -1 };
 645                 /** Set Displayed Video PID and type */
 646         virtual RESULT setVideoPID(int vpid, int type)=0;
 647
 648         enum { af_MPEG, af_AC3, af_DTS, af_AAC };
 649                 /** Set Displayed Audio PID and type */
 650         virtual RESULT setAudioPID(int apid, int type)=0;
 651
 652         enum { ac_left, ac_stereo, ac_right };
 653                 /** Set Displayed Audio Channel */
 654         virtual RESULT setAudioChannel(int channel)=0;
 655         virtual int getAudioChannel()=0;
 656
 657         virtual RESULT setPCMDelay(int delay)=0;
 658         virtual int getPCMDelay()=0;
 659         virtual RESULT setAC3Delay(int delay)=0;
 660         virtual int getAC3Delay()=0;
 661
 662                 /** Set Displayed Videotext PID */
 663         virtual RESULT setTextPID(int vpid)=0;
 664
 665                 /** Set Sync mode to PCR */
 666         virtual RESULT setSyncPCR(int pcrpid)=0;
 667         enum { sm_Audio, sm_Video };
 668                 /** Set Sync mode to either audio or video master */
 669         virtual RESULT setSyncMaster(int who)=0;
 670
 671                 /** Apply settings but don't change state */
 672         virtual RESULT set()=0;
 673                 /* all those apply settings, then transition to the given state */
 674
 675                 /** play */
 676         virtual RESULT play()=0;
 677                 /** Freeze frame. */
 678         virtual RESULT pause()=0;
 679
 680                 /** fast forward by skipping frames. 0 is disabled, 2 is twice-the-speed, ... */
 681         virtual RESULT setFastForward(int skip=0)=0;
 682
 683                 /** Slow Motion by repeating pictures */
 684         virtual RESULT setSlowMotion(int repeat)=0;
 685
 686                 /** Display any complete data as fast as possible */
 687         virtual RESULT setTrickmode()=0;
 688
 689         virtual RESULT getPTS(int what, pts_t &pts) = 0;
 690
 691         virtual RESULT showSinglePic(const char *filename) = 0;
 692
 693         virtual RESULT setRadioPic(const std::string &filename) = 0;
 694
 695         struct videoEvent
 696         {
 697                 enum { eventUnknown = 0,
 698                         eventSizeChanged = VIDEO_EVENT_SIZE_CHANGED,
 699                         eventFrameRateChanged = VIDEO_EVENT_FRAME_RATE_CHANGED,
 700                         eventProgressiveChanged = 16
 701                 } type;
 702                 unsigned char aspect;
 703                 unsigned short height;
 704                 unsigned short width;
 705                 bool progressive;
 706                 unsigned short framerate;
 707         };
 708
 709         virtual RESULT connectVideoEvent(const Slot1<void, struct videoEvent> &event, ePtr<eConnection> &connection) = 0;
 710
 711         virtual int getVideoWidth() = 0;
 712         virtual int getVideoHeight() = 0;
 713         virtual int getVideoProgressive() = 0;
 714         virtual int getVideoFrameRate() = 0;
 715         virtual int getVideoAspect() = 0;
 716 };
 717
 718 #endif //SWIG
 719 #endif