lib/dvb/idvb.h

   1 #ifndef __dvb_idvb_h
   2 #define __dvb_idvb_h
   3
   4 #include <config.h>
   5 #if HAVE_DVB_API_VERSION < 3
   6 #include <ost/frontend.h>
   7 #define FRONTENDPARAMETERS FrontendParameters
   8 #else
   9 #include <linux/dvb/frontend.h>
  10 #define FRONTENDPARAMETERS struct dvb_frontend_parameters
  11 #endif
  12 #include <lib/dvb/frontendparms.h>
  13 #include <lib/base/object.h>
  14 #include <lib/base/ebase.h>
  15 #include <lib/service/service.h>
  16 #include <libsig_comp.h>
  17 #include <connection.h>
  18
  19 struct eBouquet
  20 {
  21         std::string m_bouquet_name;
  22         std::string m_path;
  23         typedef std::list<eServiceReference> list;
  24         list m_services;
  25 // the following four methods are implemented in db.cpp
  26         RESULT flushChanges();
  27         RESULT addService(const eServiceReference &);
  28         RESULT removeService(const eServiceReference &);
  29         RESULT moveService(const eServiceReference &, unsigned int);
  30 };
  31
  32                 /* these structures have by intention no operator int() defined.
  33                    the reason of these structures is to avoid mixing for example
  34                    a onid and a tsid (as there's no general order for them).
  35
  36                    defining an operator int() would implicitely convert values
  37                    between them over the constructor with the int argument.
  38
  39                    'explicit' doesn't here - eTransportStreamID(eOriginalNetworkID(n))
  40                    would still work. */
  41
  42 struct eTransportStreamID
  43 {
  44 private:
  45         int v;
  46 public:
  47         int get() const { return v; }
  48         eTransportStreamID(int i): v(i) { }
  49         eTransportStreamID(): v(-1) { }
  50         bool operator == (const eTransportStreamID &c) const { return v == c.v; }
  51         bool operator != (const eTransportStreamID &c) const { return v != c.v; }
  52         bool operator < (const eTransportStreamID &c) const { return v < c.v; }
  53         bool operator > (const eTransportStreamID &c) const { return v > c.v; }
  54 };
  55
  56 struct eServiceID
  57 {
  58 private:
  59         int v;
  60 public:
  61         int get() const { return v; }
  62         eServiceID(int i): v(i) { }
  63         eServiceID(): v(-1) { }
  64         bool operator == (const eServiceID &c) const { return v == c.v; }
  65         bool operator != (const eServiceID &c) const { return v != c.v; }
  66         bool operator < (const eServiceID &c) const { return v < c.v; }
  67         bool operator > (const eServiceID &c) const { return v > c.v; }
  68 };
  69
  70 struct eOriginalNetworkID
  71 {
  72 private:
  73         int v;
  74 public:
  75         int get() const { return v; }
  76         eOriginalNetworkID(int i): v(i) { }
  77         eOriginalNetworkID(): v(-1) { }
  78         bool operator == (const eOriginalNetworkID &c) const { return v == c.v; }
  79         bool operator != (const eOriginalNetworkID &c) const { return v != c.v; }
  80         bool operator < (const eOriginalNetworkID &c) const { return v < c.v; }
  81         bool operator > (const eOriginalNetworkID &c) const { return v > c.v; }
  82 };
  83
  84 struct eDVBNamespace
  85 {
  86 private:
  87         int v;
  88 public:
  89         int get() const { return v; }
  90         eDVBNamespace(int i): v(i) { }
  91         eDVBNamespace(): v(-1) { }
  92         bool operator == (const eDVBNamespace &c) const { return v == c.v; }
  93         bool operator != (const eDVBNamespace &c) const { return v != c.v; }
  94         bool operator < (const eDVBNamespace &c) const { return v < c.v; }
  95         bool operator > (const eDVBNamespace &c) const { return v > c.v; }
  96 };
  97
  98 struct eDVBChannelID
  99 {
 100         eDVBNamespace dvbnamespace;
 101         eTransportStreamID transport_stream_id;
 102         eOriginalNetworkID original_network_id;
 103
 104         bool operator==(const eDVBChannelID &c) const
 105         {
 106                 return dvbnamespace == c.dvbnamespace &&
 107                         transport_stream_id == c.transport_stream_id &&
 108                         original_network_id == c.original_network_id;
 109         }
 110
 111         bool operator<(const eDVBChannelID &c) const
 112         {
 113                 if (dvbnamespace < c.dvbnamespace)
 114                         return 1;
 115                 else if (dvbnamespace == c.dvbnamespace)
 116                 {
 117                         if (original_network_id < c.original_network_id)
 118                                 return 1;
 119                         else if (original_network_id == c.original_network_id)
 120                                 if (transport_stream_id < c.transport_stream_id)
 121                                         return 1;
 122                 }
 123                 return 0;
 124         }
 125         eDVBChannelID(eDVBNamespace dvbnamespace, eTransportStreamID tsid, eOriginalNetworkID onid):
 126                         dvbnamespace(dvbnamespace), transport_stream_id(tsid), original_network_id(onid)
 127         {
 128         }
 129         eDVBChannelID():
 130                         dvbnamespace(-1), transport_stream_id(-1), original_network_id(-1)
 131         {
 132         }
 133         operator bool() const
 134         {
 135                 return (dvbnamespace != -1) && (transport_stream_id != -1) && (original_network_id != -1);
 136         }
 137 };
 138
 139 struct eServiceReferenceDVB: public eServiceReference
 140 {
 141         int getServiceType() const { return data[0]; }
 142         void setServiceType(int service_type) { data[0]=service_type; }
 143
 144         eServiceID getServiceID() const { return eServiceID(data[1]); }
 145         void setServiceID(eServiceID service_id) { data[1]=service_id.get(); }
 146
 147         eTransportStreamID getTransportStreamID() const { return eTransportStreamID(data[2]); }
 148         void setTransportStreamID(eTransportStreamID transport_stream_id) { data[2]=transport_stream_id.get(); }
 149
 150         eOriginalNetworkID getOriginalNetworkID() const { return eOriginalNetworkID(data[3]); }
 151         void setOriginalNetworkID(eOriginalNetworkID original_network_id) { data[3]=original_network_id.get(); }
 152
 153         eDVBNamespace getDVBNamespace() const { return eDVBNamespace(data[4]); }
 154         void setDVBNamespace(eDVBNamespace dvbnamespace) { data[4]=dvbnamespace.get(); }
 155
 156         eServiceReferenceDVB(eDVBNamespace dvbnamespace, eTransportStreamID transport_stream_id, eOriginalNetworkID original_network_id, eServiceID service_id, int service_type)
 157                 :eServiceReference(eServiceReference::idDVB, 0)
 158         {
 159                 setTransportStreamID(transport_stream_id);
 160                 setOriginalNetworkID(original_network_id);
 161                 setDVBNamespace(dvbnamespace);
 162                 setServiceID(service_id);
 163                 setServiceType(service_type);
 164         }
 165
 166         void set(const eDVBChannelID &chid)
 167         {
 168                 setDVBNamespace(chid.dvbnamespace);
 169                 setOriginalNetworkID(chid.original_network_id);
 170                 setTransportStreamID(chid.transport_stream_id);
 171         }
 172
 173         void getChannelID(eDVBChannelID &chid) const
 174         {
 175                 chid = eDVBChannelID(getDVBNamespace(), getTransportStreamID(), getOriginalNetworkID());
 176         }
 177
 178         eServiceReferenceDVB()
 179                 :eServiceReference(eServiceReference::idDVB, 0)
 180         {
 181         }
 182 };
 183
 184
 185 ////////////////// TODO: we need an interface here, but what exactly?
 186
 187 #include <set>
 188 // btw, still implemented in db.cpp. FIX THIS, TOO.
 189
 190 class eDVBChannelQuery;
 191
 192 class eDVBService: public iStaticServiceInformation
 193 {
 194         DECLARE_REF(eDVBService);
 195 public:
 196         enum cacheID
 197         {
 198                 cVPID, cAPID, cTPID, cPCRPID, cAC3PID, cacheMax
 199         };
 200
 201         int getCachePID(cacheID);
 202         void setCachePID(cacheID, int);
 203         bool cacheEmpty() { return m_cache.empty(); }
 204
 205         eDVBService();
 206                 /* m_service_name_sort is uppercase, with special chars removed, to increase sort performance. */
 207         std::string m_service_name, m_service_name_sort;
 208         std::string m_provider_name;
 209
 210         void genSortName();
 211
 212         int m_flags;
 213         std::set<int> m_ca;
 214         std::map<int,int> m_cache;
 215         virtual ~eDVBService();
 216
 217         eDVBService &operator=(const eDVBService &);
 218
 219         // iStaticServiceInformation
 220         RESULT getName(const eServiceReference &ref, std::string &name);
 221         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr);
 222         bool isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 223
 224                 /* for filtering: */
 225         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 226 };
 227
 228 //////////////////
 229
 230 class iDVBChannel;
 231 class iDVBDemux;
 232 class iDVBFrontendParameters;
 233
 234 class iDVBChannelListQuery: public iObject
 235 {
 236 public:
 237         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 238         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 239 };
 240
 241 class eDVBChannelQuery: public iObject
 242 {
 243         DECLARE_REF(eDVBChannelQuery);
 244 public:
 245         enum
 246         {
 247                 tName,
 248                 tProvider,
 249                 tType,
 250                 tBouquet,
 251                 tSatellitePosition,
 252                 tChannelID,
 253                 tAND,
 254                 tOR
 255         };
 256
 257         int m_type;
 258         int m_inverse;
 259
 260         std::string m_string;
 261         int m_int;
 262         eDVBChannelID m_channelid;
 263
 264                 /* sort is only valid in root, and must be from the enum above. */
 265         int m_sort;
 266         std::string m_bouquet_name;
 267
 268         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 269
 270         ePtr<eDVBChannelQuery> m_p1, m_p2;
 271 };
 272
 273 class iDVBChannelList: public iObject
 274 {
 275 public:
 276         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 277         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 278
 279         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 280
 281         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
 282         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 283         virtual RESULT flush()=0;
 284
 285         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 286
 287         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
 288 };
 289
 290 class iDVBFrontendParameters: public iObject
 291 {
 292 public:
 293         virtual RESULT getSystem(int &type) const = 0;
 294         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
 295         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
 296         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
 297
 298         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
 299         virtual RESULT getHash(unsigned long &hash) const = 0;
 300 };
 301
 302 #define MAX_DISEQC_LENGTH  16
 303
 304 class eDVBDiseqcCommand
 305 {
 306 public:
 307         int len;
 308         __u8 data[MAX_DISEQC_LENGTH];
 309 #if HAVE_DVB_API_VERSION < 3
 310         int tone;
 311         int voltage;
 312 #endif
 313 };
 314
 315 class iDVBSatelliteEquipmentControl;
 316 class eSecCommandList;
 317
 318 class iDVBFrontend: public iObject
 319 {
 320 public:
 321         enum {
 322                 feSatellite, feCable, feTerrestrial
 323         };
 324         virtual RESULT getFrontendType(int &type)=0;
 325         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 326         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 327         enum {
 328                 stateIdle = 0,
 329                 stateTuning = 1,
 330                 stateFailed = 2,
 331                 stateLock = 3,
 332                 stateLostLock = 4,
 333         };
 334         virtual RESULT getState(int &state)=0;
 335         enum {
 336                 toneOff, toneOn
 337         };
 338         virtual RESULT setTone(int tone)=0;
 339         enum {
 340                 voltageOff, voltage13, voltage18
 341         };
 342         virtual RESULT setVoltage(int voltage)=0;
 343         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 344         virtual RESULT sendToneburst(int burst)=0;
 345         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 346         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 347
 348         enum {
 349                 bitErrorRate, signalPower, signalQuality
 350         };
 351         virtual int readFrontendData(int type)=0;
 352
 353         virtual RESULT getData(int num, int &data)=0;
 354         virtual RESULT setData(int num, int val)=0;
 355
 356                 /* 0 means: not compatible. other values are a priority. */
 357         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 358 };
 359
 360 class iDVBSatelliteEquipmentControl: public iObject
 361 {
 362 public:
 363         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 364         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 365         virtual void setRotorMoving(bool)=0;
 366 };
 367
 368 struct eDVBCIRouting
 369 {
 370         int enabled;
 371 };
 372
 373 class iDVBChannel: public iObject
 374 {
 375 public:
 376         enum
 377         {
 378                 state_idle,        /* not yet tuned */
 379                 state_tuning,      /* currently tuning (first time) */
 380                 state_failed,      /* tuning failed. */
 381                 state_unavailable, /* currently unavailable, will be back without further interaction */
 382                 state_ok,          /* ok */
 383                 state_release      /* channel is being shut down. */
 384         };
 385         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 386         virtual RESULT getState(int &state)=0;
 387
 388                 /* demux capabilities */
 389         enum
 390         {
 391                 capDecode = 1,
 392                 /* capCI = 2 */
 393         };
 394         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 395         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 396
 397                 /* direct frontend access for raw channels and/or status inquiries. */
 398         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
 399
 400                 /* use count handling */
 401         virtual void AddUse() = 0;
 402         virtual void ReleaseUse() = 0;
 403 };
 404
 405         /* signed, so we can express deltas. */
 406 typedef long long pts_t;
 407
 408 class iDVBPVRChannel: public iDVBChannel
 409 {
 410 public:
 411         enum
 412         {
 413                 state_eof = state_release + 1  /* end-of-file reached. */
 414         };
 415
 416                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 417                 /* so this is VERY UGLY. */
 418         virtual RESULT playFile(const char *file) = 0;
 419
 420         virtual RESULT getLength(pts_t &pts) = 0;
 421
 422                 /* we explicitely ask for the decoding demux here because a channel
 423                    can be shared between multiple decoders.
 424                    Of couse skipping doesn't make much sense
 425                    then, but getCurrentPosition does. */
 426         virtual RESULT getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos) = 0;
 427         virtual RESULT seekTo(iDVBDemux *decoding_demux, int relative, pts_t &pts) = 0;
 428         virtual RESULT seekToPosition(iDVBDemux *decoding_demux, const off_t &pts) = 0;
 429 };
 430
 431 class iDVBSectionReader;
 432 class iDVBTSRecorder;
 433 class iTSMPEGDecoder;
 434
 435 class iDVBDemux: public iObject
 436 {
 437 public:
 438         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 439         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 440         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 441         virtual RESULT getSTC(pts_t &pts)=0;
 442         virtual RESULT getCADemuxID(uint8_t &id)=0;
 443         virtual RESULT flush()=0;
 444 };
 445
 446 class iTSMPEGDecoder: public iObject
 447 {
 448 public:
 449         enum { pidDisabled = -1 };
 450                 /** Set Displayed Video PID */
 451         virtual RESULT setVideoPID(int vpid)=0;
 452
 453         enum { af_MPEG, af_AC3, af_DTS };
 454                 /** Set Displayed Audio PID and type */
 455         virtual RESULT setAudioPID(int apid, int type)=0;
 456
 457                 /** Set Sync mode to PCR */
 458         virtual RESULT setSyncPCR(int pcrpid)=0;
 459         enum { sm_Audio, sm_Video };
 460                 /** Set Sync mode to either audio or video master */
 461         virtual RESULT setSyncMaster(int who)=0;
 462
 463                 /** Apply settings */
 464         virtual RESULT start()=0;
 465
 466                 /** Freeze frame. Either continue decoding (without display) or halt. */
 467         virtual RESULT freeze(int cont)=0;
 468                 /** Continue after freeze. */
 469         virtual RESULT unfreeze()=0;
 470
 471                 // stop on .. Picture
 472         enum { spm_I, spm_Ref, spm_Any };
 473                 /** Stop on specific decoded picture. For I-Frame display. */
 474         virtual RESULT setSinglePictureMode(int when)=0;
 475
 476         enum { pkm_B, pkm_PB };
 477                 /** Fast forward by skipping either B or P/B pictures */
 478         virtual RESULT setPictureSkipMode(int what)=0;
 479
 480                 /** Slow Motion by repeating pictures */
 481         virtual RESULT setSlowMotion(int repeat)=0;
 482
 483         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 484                 /** Set Zoom. mode *must* be fitting. */
 485         virtual RESULT setZoom(int what)=0;
 486 };
 487
 488 #endif