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, public iStreamableService
  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                 // iStreamableService
 181         RESULT stream(ePtr<iStreamableService> &ptr);
 182         PyObject *getStreamingData();
 183 private:
 184         friend class eServiceFactoryDVB;
 185         eServiceReference m_reference;
 186
 187         ePtr<eDVBService> m_dvb_service;
 188
 189         ePtr<iTSMPEGDecoder> m_decoder;
 190         int m_is_primary;
 191         int m_have_video_pid;
 192         int m_tune_state;
 193
 194                 /* in timeshift mode, we essentially have two channels, and thus pmt handlers. */
 195         eDVBServicePMTHandler m_service_handler_timeshift;
 196         eDVBServiceEITHandler m_event_handler;
 197
 198         eDVBServicePlay(const eServiceReference &ref, eDVBService *service);
 199
 200                 /* events */
 201         void gotNewEvent();
 202
 203         void serviceEvent(int event);
 204         void serviceEventTimeshift(int event);
 205         Signal2<void,iPlayableService*,int> m_event;
 206
 207                 /* pvr */
 208         int m_is_pvr, m_is_paused, m_timeshift_enabled, m_timeshift_active;
 209         int m_first_program_info;
 210
 211         std::string m_timeshift_file;
 212         int m_timeshift_fd;
 213
 214         ePtr<iDVBDemux> m_decode_demux;
 215
 216         int m_current_audio_stream;
 217         int selectAudioStream(int n);
 218
 219                 /* timeshift */
 220         ePtr<iDVBTSRecorder> m_record;
 221         std::set<int> m_pids_active;
 222
 223         void updateTimeshiftPids();
 224         void switchToLive();
 225         void switchToTimeshift();
 226
 227         void updateDecoder();
 228
 229         int m_skipmode;
 230
 231                 /* cuesheet */
 232
 233         ePtr<eCueSheet> m_cue;
 234
 235         struct cueEntry
 236         {
 237                 pts_t where;
 238                 unsigned int what;
 239
 240                 bool operator < (const struct cueEntry &o) const
 241                 {
 242                         return where < o.where;
 243                 }
 244                 cueEntry(const pts_t &where, unsigned int what) :
 245                         where(where), what(what)
 246                 {
 247                 }
 248         };
 249
 250         std::multiset<cueEntry> m_cue_entries;
 251         int m_cuesheet_changed, m_cutlist_enabled;
 252
 253         void loadCuesheet();
 254         void saveCuesheet();
 255
 256         void cutlistToCuesheet();
 257
 258         eSubtitleWidget *m_subtitle_widget;
 259
 260                 /* teletext subtitles */
 261         ePtr<eDVBTeletextParser> m_teletext_parser;
 262         void newSubtitlePage(const eDVBTeletextSubtitlePage &p);
 263         ePtr<eConnection> m_new_subtitle_page_connection;
 264         std::list<eDVBTeletextSubtitlePage> m_subtitle_pages;
 265
 266                 /* dvb subtitles */
 267         ePtr<eDVBSubtitleParser> m_subtitle_parser;
 268         void newDVBSubtitlePage(const eDVBSubtitlePage &p);
 269         ePtr<eConnection> m_new_dvb_subtitle_page_connection;
 270         std::list<eDVBSubtitlePage> m_dvb_subtitle_pages;
 271
 272         eTimer m_subtitle_sync_timer;
 273         void checkSubtitleTiming();
 274
 275                 /* radiotext */
 276         ePtr<eDVBRdsDecoder> m_rds_decoder;
 277         ePtr<eConnection> m_rds_decoder_event_connection;
 278         void rdsDecoderEvent(int);
 279
 280         ePtr<eConnection> m_video_event_connection;
 281         void video_event(struct iTSMPEGDecoder::videoEvent);
 282         struct iTSMPEGDecoder::videoEvent m_videoEventData;
 283 };
 284
 285 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
 286 {
 287         DECLARE_REF(eStaticServiceDVBBouquetInformation);
 288         eServiceReference m_playable_service;
 289 public:
 290         eServiceReference &getPlayableService() { return m_playable_service; }
 291         RESULT getName(const eServiceReference &ref, std::string &name);
 292         int getLength(const eServiceReference &ref);
 293         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
 294         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 295 };
 296
 297 #endif