lib/service/servicedvb.h

   1 #ifndef __servicedvb_h
   2 #define __servicedvb_h
   3
   4 #include <lib/service/iservice.h>
   5 #include <lib/dvb/idvb.h>
   6
   7 #include <lib/dvb/pmt.h>
   8 #include <lib/dvb/eit.h>
   9 #include <lib/dvb/subtitle.h>
  10 #include <lib/dvb/teletext.h>
  11 #include <lib/dvb/radiotext.h>
  12 #include <lib/base/filepush.h>
  13
  14 class eStaticServiceDVBInformation;
  15 class eStaticServiceDVBBouquetInformation;
  16
  17 class eServiceFactoryDVB: public iServiceHandler
  18 {
  19         DECLARE_REF(eServiceFactoryDVB);
  20         ePtr<eStaticServiceDVBInformation> m_StaticServiceDVBInfo;
  21         ePtr<eStaticServiceDVBBouquetInformation> m_StaticServiceDVBBouquetInfo;
  22 public:
  23         eServiceFactoryDVB();
  24         virtual ~eServiceFactoryDVB();
  25         enum { id = 0x1 };
  26
  27                 // iServiceHandler
  28         RESULT play(const eServiceReference &, ePtr<iPlayableService> &ptr);
  29         RESULT record(const eServiceReference &, ePtr<iRecordableService> &ptr);
  30         RESULT list(const eServiceReference &, ePtr<iListableService> &ptr);
  31         RESULT info(const eServiceReference &, ePtr<iStaticServiceInformation> &ptr);
  32         RESULT offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &ptr);
  33 private:
  34         RESULT lookupService(ePtr<eDVBService> &ptr, const eServiceReference &ref);
  35 };
  36
  37 class eBouquet;
  38
  39 class eDVBServiceList: public iListableService, public iMutableServiceList
  40 {
  41 DECLARE_REF(eDVBServiceList);
  42 public:
  43         virtual ~eDVBServiceList();
  44         PyObject *getContent(const char* formatstr, bool sorted=false);
  45         RESULT getContent(std::list<eServiceReference> &list, bool sorted=false);
  46         RESULT getNext(eServiceReference &ptr);
  47         inline int compareLessEqual(const eServiceReference &a, const eServiceReference &b);
  48
  49         RESULT startEdit(ePtr<iMutableServiceList> &);
  50         RESULT flushChanges();
  51         RESULT addService(eServiceReference &ref, eServiceReference before);
  52         RESULT removeService(eServiceReference &ref);
  53         RESULT moveService(eServiceReference &ref, int pos);
  54         RESULT setListName(const std::string &name);
  55 private:
  56         RESULT startQuery();
  57         eServiceReference m_parent;
  58         friend class eServiceFactoryDVB;
  59         eDVBServiceList(const eServiceReference &parent);
  60         ePtr<iDVBChannelListQuery> m_query;
  61
  62                 /* for editing purposes. WARNING: lifetime issue! */
  63         eBouquet *m_bouquet;
  64 };
  65
  66 inline int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
  67 {
  68         return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
  69 }
  70
  71 class eDVBServiceBase: public iFrontendInformation
  72 {
  73 protected:
  74         eDVBServicePMTHandler m_service_handler;
  75 public:
  76                 // iFrontendInformation
  77         int getFrontendInfo(int w);
  78         PyObject *getFrontendData();
  79         PyObject *getFrontendStatus();
  80         PyObject *getTransponderData(bool);
  81         PyObject *getAll(bool original); // a sum of getFrontendData/Status/TransponderData
  82 };
  83
  84 class eSubtitleWidget;
  85
  86 class eDVBServicePlay: public eDVBServiceBase,
  87                 public iPlayableService, public iPauseableService,
  88                 public iSeekableService, public Object, public iServiceInformation,
  89                 public iAudioTrackSelection, public iAudioChannelSelection,
  90                 public iSubserviceList, public iTimeshiftService,
  91                 public iCueSheet, public iSubtitleOutput, public iAudioDelay,
  92                 public iRdsDecoder
  93 {
  94 DECLARE_REF(eDVBServicePlay);
  95 public:
  96         virtual ~eDVBServicePlay();
  97
  98                 // iPlayableService
  99         RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection);
 100         RESULT start();
 101         RESULT stop();
 102         RESULT setTarget(int target);
 103
 104         RESULT seek(ePtr<iSeekableService> &ptr);
 105         RESULT pause(ePtr<iPauseableService> &ptr);
 106         RESULT info(ePtr<iServiceInformation> &ptr);
 107         RESULT audioChannel(ePtr<iAudioChannelSelection> &ptr);
 108         RESULT audioTracks(ePtr<iAudioTrackSelection> &ptr);
 109         RESULT frontendInfo(ePtr<iFrontendInformation> &ptr);
 110         RESULT subServices(ePtr<iSubserviceList> &ptr);
 111         RESULT timeshift(ePtr<iTimeshiftService> &ptr);
 112         RESULT cueSheet(ePtr<iCueSheet> &ptr);
 113         RESULT subtitle(ePtr<iSubtitleOutput> &ptr);
 114         RESULT audioDelay(ePtr<iAudioDelay> &ptr);
 115         RESULT rdsDecoder(ePtr<iRdsDecoder> &ptr);
 116
 117                 // iPauseableService
 118         RESULT pause();
 119         RESULT unpause();
 120         RESULT setSlowMotion(int ratio);
 121         RESULT setFastForward(int ratio);
 122
 123                 // iSeekableService
 124         RESULT getLength(pts_t &len);
 125         RESULT seekTo(pts_t to);
 126         RESULT seekRelative(int direction, pts_t to);
 127         RESULT getPlayPosition(pts_t &pos);
 128         RESULT setTrickmode(int trick=0);
 129         RESULT isCurrentlySeekable();
 130
 131                 // iServiceInformation
 132         RESULT getName(std::string &name);
 133         RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
 134         int getInfo(int w);
 135         std::string getInfoString(int w);
 136         PyObject *getInfoObject(int w);
 137
 138                 // iAudioTrackSelection
 139         int getNumberOfTracks();
 140         RESULT selectTrack(unsigned int i);
 141         RESULT getTrackInfo(struct iAudioTrackInfo &, unsigned int n);
 142
 143                 // iAudioChannelSelection
 144         int getCurrentChannel();
 145         RESULT selectChannel(int i);
 146
 147                 // iRdsDecoder
 148         std::string getText(int i=0);
 149         void showRassSlidePicture();
 150         void showRassInteractivePic(int page, int subpage);
 151         ePyObject getRassInteractiveMask();
 152
 153                 // iSubserviceList
 154         int getNumberOfSubservices();
 155         RESULT getSubservice(eServiceReference &subservice, unsigned int n);
 156
 157                 // iTimeshiftService
 158         RESULT startTimeshift();
 159         RESULT stopTimeshift();
 160         int isTimeshiftActive();
 161         RESULT activateTimeshift();
 162
 163                 // iCueSheet
 164         PyObject *getCutList();
 165         void setCutList(SWIG_PYOBJECT(ePyObject));
 166         void setCutListEnable(int enable);
 167
 168                 // iSubtitleOutput
 169         RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry);
 170         RESULT disableSubtitles(eWidget *parent);
 171         PyObject *getSubtitleList();
 172         PyObject *getCachedSubtitle();
 173
 174                 // iAudioDelay
 175         int getAC3Delay();
 176         int getPCMDelay();
 177         void setAC3Delay(int);
 178         void setPCMDelay(int);
 179
 180 private:
 181         friend class eServiceFactoryDVB;
 182         eServiceReference m_reference;
 183
 184         ePtr<eDVBService> m_dvb_service;
 185
 186         ePtr<iTSMPEGDecoder> m_decoder;
 187         int m_is_primary;
 188         int m_have_video_pid;
 189         int m_tune_state;
 190
 191                 /* in timeshift mode, we essentially have two channels, and thus pmt handlers. */
 192         eDVBServicePMTHandler m_service_handler_timeshift;
 193         eDVBServiceEITHandler m_event_handler;
 194
 195         eDVBServicePlay(const eServiceReference &ref, eDVBService *service);
 196
 197                 /* events */
 198         void gotNewEvent();
 199
 200         void serviceEvent(int event);
 201         void serviceEventTimeshift(int event);
 202         Signal2<void,iPlayableService*,int> m_event;
 203
 204                 /* pvr */
 205         int m_is_pvr, m_is_paused, m_timeshift_enabled, m_timeshift_active;
 206         int m_first_program_info;
 207
 208         std::string m_timeshift_file;
 209         int m_timeshift_fd;
 210
 211         ePtr<iDVBDemux> m_decode_demux;
 212
 213         int m_current_audio_stream;
 214         int selectAudioStream(int n);
 215
 216                 /* timeshift */
 217         ePtr<iDVBTSRecorder> m_record;
 218         std::set<int> m_pids_active;
 219
 220         void updateTimeshiftPids();
 221         void switchToLive();
 222         void switchToTimeshift();
 223
 224         void updateDecoder();
 225
 226         int m_skipmode;
 227
 228                 /* cuesheet */
 229
 230         ePtr<eCueSheet> m_cue;
 231
 232         struct cueEntry
 233         {
 234                 pts_t where;
 235                 unsigned int what;
 236
 237                 bool operator < (const struct cueEntry &o) const
 238                 {
 239                         return where < o.where;
 240                 }
 241                 cueEntry(const pts_t &where, unsigned int what) :
 242                         where(where), what(what)
 243                 {
 244                 }
 245         };
 246
 247         std::multiset<cueEntry> m_cue_entries;
 248         int m_cuesheet_changed, m_cutlist_enabled;
 249
 250         void loadCuesheet();
 251         void saveCuesheet();
 252
 253         void cutlistToCuesheet();
 254
 255         eSubtitleWidget *m_subtitle_widget;
 256
 257                 /* teletext subtitles */
 258         ePtr<eDVBTeletextParser> m_teletext_parser;
 259         void newSubtitlePage(const eDVBTeletextSubtitlePage &p);
 260         ePtr<eConnection> m_new_subtitle_page_connection;
 261         std::list<eDVBTeletextSubtitlePage> m_subtitle_pages;
 262
 263                 /* dvb subtitles */
 264         ePtr<eDVBSubtitleParser> m_subtitle_parser;
 265         void newDVBSubtitlePage(const eDVBSubtitlePage &p);
 266         ePtr<eConnection> m_new_dvb_subtitle_page_connection;
 267         std::list<eDVBSubtitlePage> m_dvb_subtitle_pages;
 268
 269         eTimer m_subtitle_sync_timer;
 270         void checkSubtitleTiming();
 271
 272                 /* radiotext */
 273         ePtr<eDVBRdsDecoder> m_rds_decoder;
 274         ePtr<eConnection> m_rds_decoder_event_connection;
 275         void rdsDecoderEvent(int);
 276
 277         ePtr<eConnection> m_video_event_connection;
 278         void video_event(struct iTSMPEGDecoder::videoEvent);
 279         struct iTSMPEGDecoder::videoEvent m_videoEventData;
 280 };
 281
 282 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
 283 {
 284         DECLARE_REF(eStaticServiceDVBBouquetInformation);
 285         eServiceReference m_playable_service;
 286 public:
 287         eServiceReference &getPlayableService() { return m_playable_service; }
 288         RESULT getName(const eServiceReference &ref, std::string &name);
 289         int getLength(const eServiceReference &ref);
 290         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 291         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 292 };
 293
 294 #endif