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         int getLength(const eServiceReference &ref);
 222
 223                 /* for filtering: */
 224         int checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query);
 225 };
 226
 227 //////////////////
 228
 229 class iDVBChannel;
 230 class iDVBDemux;
 231 class iDVBFrontendParameters;
 232
 233 class iDVBChannelListQuery: public iObject
 234 {
 235 public:
 236         virtual RESULT getNextResult(eServiceReferenceDVB &ref)=0;
 237         virtual int compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)=0;
 238 };
 239
 240 class eDVBChannelQuery: public iObject
 241 {
 242         DECLARE_REF(eDVBChannelQuery);
 243 public:
 244         enum
 245         {
 246                 tName,
 247                 tProvider,
 248                 tType,
 249                 tBouquet,
 250                 tSatellitePosition,
 251                 tChannelID,
 252                 tAND,
 253                 tOR
 254         };
 255
 256         int m_type;
 257         int m_inverse;
 258
 259         std::string m_string;
 260         int m_int;
 261         eDVBChannelID m_channelid;
 262
 263                 /* sort is only valid in root, and must be from the enum above. */
 264         int m_sort;
 265         std::string m_bouquet_name;
 266
 267         static RESULT compile(ePtr<eDVBChannelQuery> &res, std::string query);
 268
 269         ePtr<eDVBChannelQuery> m_p1, m_p2;
 270 };
 271
 272 class iDVBChannelList: public iObject
 273 {
 274 public:
 275         virtual RESULT addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)=0;
 276         virtual RESULT removeChannel(const eDVBChannelID &id)=0;
 277
 278         virtual RESULT getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)=0;
 279
 280         virtual RESULT addService(const eServiceReferenceDVB &service, eDVBService *service)=0;
 281         virtual RESULT getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)=0;
 282
 283         virtual RESULT getBouquet(const eServiceReference &ref,  eBouquet* &bouquet)=0;
 284
 285         virtual RESULT startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *query, const eServiceReference &source)=0;
 286 };
 287
 288 class iDVBFrontendParameters: public iObject
 289 {
 290 public:
 291         virtual RESULT getSystem(int &type) const = 0;
 292         virtual RESULT getDVBS(eDVBFrontendParametersSatellite &p) const = 0;
 293         virtual RESULT getDVBC(eDVBFrontendParametersCable &p) const = 0;
 294         virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &p) const = 0;
 295
 296         virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &diff) const = 0;
 297         virtual RESULT getHash(unsigned long &hash) const = 0;
 298 };
 299
 300 #define MAX_DISEQC_LENGTH  16
 301
 302 class eDVBDiseqcCommand
 303 {
 304 public:
 305         int len;
 306         __u8 data[MAX_DISEQC_LENGTH];
 307 #if HAVE_DVB_API_VERSION < 3
 308         int tone;
 309         int voltage;
 310 #endif
 311 };
 312
 313 class iDVBSatelliteEquipmentControl;
 314 class eSecCommandList;
 315
 316 class iDVBFrontend: public iObject
 317 {
 318 public:
 319         enum {
 320                 feSatellite, feCable, feTerrestrial
 321         };
 322         virtual RESULT getFrontendType(int &type)=0;
 323         virtual RESULT tune(const iDVBFrontendParameters &where)=0;
 324         virtual RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)=0;
 325         enum {
 326                 stateIdle = 0,
 327                 stateTuning = 1,
 328                 stateFailed = 2,
 329                 stateLock = 3,
 330                 stateLostLock = 4,
 331         };
 332         virtual RESULT getState(int &state)=0;
 333         enum {
 334                 toneOff, toneOn
 335         };
 336         virtual RESULT setTone(int tone)=0;
 337         enum {
 338                 voltageOff, voltage13, voltage18
 339         };
 340         virtual RESULT setVoltage(int voltage)=0;
 341         virtual RESULT sendDiseqc(const eDVBDiseqcCommand &diseqc)=0;
 342         virtual RESULT sendToneburst(int burst)=0;
 343         virtual RESULT setSEC(iDVBSatelliteEquipmentControl *sec)=0;
 344         virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 345         virtual RESULT getData(int num, int &data)=0;
 346         virtual RESULT setData(int num, int val)=0;
 347
 348                 /* 0 means: not compatible. other values are a priority. */
 349         virtual int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)=0;
 350 };
 351
 352 class iDVBSatelliteEquipmentControl: public iObject
 353 {
 354 public:
 355         virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
 356         virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
 357 };
 358
 359 struct eDVBCIRouting
 360 {
 361         int enabled;
 362 };
 363
 364 class iDVBChannel: public iObject
 365 {
 366 public:
 367         enum
 368         {
 369                 state_idle,        /* not yet tuned */
 370                 state_tuning,      /* currently tuning (first time) */
 371                 state_failed,      /* tuning failed. */
 372                 state_unavailable, /* currently unavailable, will be back without further interaction */
 373                 state_ok,          /* ok */
 374                 state_release      /* channel is being shut down. */
 375         };
 376         virtual RESULT connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)=0;
 377         virtual RESULT getState(int &state)=0;
 378
 379                 /* demux capabilities */
 380         enum
 381         {
 382                 capDecode = 1,
 383                 /* capCI = 2 */
 384         };
 385         virtual RESULT setCIRouting(const eDVBCIRouting &routing)=0;
 386         virtual RESULT getDemux(ePtr<iDVBDemux> &demux, int cap=0)=0;
 387
 388                 /* direct frontend access for raw channels and/or status inquiries. */
 389         virtual RESULT getFrontend(ePtr<iDVBFrontend> &frontend)=0;
 390
 391                 /* use count handling */
 392         virtual void AddUse() = 0;
 393         virtual void ReleaseUse() = 0;
 394 };
 395
 396         /* signed, so we can express deltas. */
 397 typedef long long pts_t;
 398
 399 class iDVBPVRChannel: public iDVBChannel
 400 {
 401 public:
 402         enum
 403         {
 404                 state_eof = state_release + 1  /* end-of-file reached. */
 405         };
 406
 407                 /* FIXME: there are some very ugly buffer-end and ... related problems */
 408                 /* so this is VERY UGLY. */
 409         virtual RESULT playFile(const char *file) = 0;
 410
 411         virtual RESULT getLength(pts_t &pts) = 0;
 412         virtual RESULT getCurrentPosition(pts_t &pos) = 0;
 413         virtual RESULT seekTo(int relative, pts_t &pts) = 0;
 414         virtual RESULT seekToPosition(const off_t &pts) = 0;
 415 };
 416
 417 class iDVBSectionReader;
 418 class iDVBTSRecorder;
 419 class iTSMPEGDecoder;
 420
 421 class iDVBDemux: public iObject
 422 {
 423 public:
 424         virtual RESULT createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)=0;
 425         virtual RESULT createTSRecorder(ePtr<iDVBTSRecorder> &recorder)=0;
 426         virtual RESULT getMPEGDecoder(ePtr<iTSMPEGDecoder> &reader)=0;
 427         virtual RESULT getSTC(pts_t &pts)=0;
 428         virtual RESULT getCADemuxID(uint8_t &id)=0;
 429         virtual RESULT flush()=0;
 430 };
 431
 432 class iTSMPEGDecoder: public iObject
 433 {
 434 public:
 435         enum { pidDisabled = -1 };
 436                 /** Set Displayed Video PID */
 437         virtual RESULT setVideoPID(int vpid)=0;
 438
 439         enum { af_MPEG, af_AC3, af_DTS };
 440                 /** Set Displayed Audio PID and type */
 441         virtual RESULT setAudioPID(int apid, int type)=0;
 442
 443                 /** Set Sync mode to PCR */
 444         virtual RESULT setSyncPCR(int pcrpid)=0;
 445         enum { sm_Audio, sm_Video };
 446                 /** Set Sync mode to either audio or video master */
 447         virtual RESULT setSyncMaster(int who)=0;
 448
 449                 /** Apply settings */
 450         virtual RESULT start()=0;
 451
 452                 /** Freeze frame. Either continue decoding (without display) or halt. */
 453         virtual RESULT freeze(int cont)=0;
 454                 /** Continue after freeze. */
 455         virtual RESULT unfreeze()=0;
 456
 457                 // stop on .. Picture
 458         enum { spm_I, spm_Ref, spm_Any };
 459                 /** Stop on specific decoded picture. For I-Frame display. */
 460         virtual RESULT setSinglePictureMode(int when)=0;
 461
 462         enum { pkm_B, pkm_PB };
 463                 /** Fast forward by skipping either B or P/B pictures */
 464         virtual RESULT setPictureSkipMode(int what)=0;
 465
 466                 /** Slow Motion by repeating pictures */
 467         virtual RESULT setSlowMotion(int repeat)=0;
 468
 469         enum { zoom_Normal, zoom_PanScan, zoom_Letterbox, zoom_Fullscreen };
 470                 /** Set Zoom. mode *must* be fitting. */
 471         virtual RESULT setZoom(int what)=0;
 472 };
 473
 474 #endif