code.vuplus.com Git - vuplus_dvbapp/blob - 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         RESULT keys(ePtr<iServiceKeys> &ptr) { ptr = 0; return -1; }
 117         RESULT streamed(ePtr<iStreamedService> &ptr) { ptr = 0; return -1; }
 118
 119                 // iPauseableService
 120         RESULT pause();
 121         RESULT unpause();
 122         RESULT setSlowMotion(int ratio);
 123         RESULT setFastForward(int ratio);
 124
 125                 // iSeekableService
 126         RESULT getLength(pts_t &len);
 127         RESULT seekTo(pts_t to);
 128         RESULT seekRelative(int direction, pts_t to);
 129         RESULT getPlayPosition(pts_t &pos);
 130         RESULT setTrickmode(int trick=0);
 131         RESULT isCurrentlySeekable();
 132
 133                 // iServiceInformation
 134         RESULT getName(std::string &name);
 135         RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
 136         int getInfo(int w);
 137         std::string getInfoString(int w);
 138         PyObject *getInfoObject(int w);
 139
 140                 // iAudioTrackSelection
 141         int getNumberOfTracks();
 142         RESULT selectTrack(unsigned int i);
 143         RESULT getTrackInfo(struct iAudioTrackInfo &, unsigned int n);
 144         int getCurrentTrack();
 145
 146                 // iAudioChannelSelection
 147         int getCurrentChannel();
 148         RESULT selectChannel(int i);
 149
 150                 // iRdsDecoder
 151         std::string getText(int i=0);
 152         void showRassSlidePicture();
 153         void showRassInteractivePic(int page, int subpage);
 154         ePyObject getRassInteractiveMask();
 155
 156                 // iSubserviceList
 157         int getNumberOfSubservices();
 158         RESULT getSubservice(eServiceReference &subservice, unsigned int n);
 159
 160                 // iTimeshiftService
 161         RESULT startTimeshift();
 162         RESULT stopTimeshift(bool swToLive=true);
 163         int isTimeshiftActive();
 164         RESULT activateTimeshift();
 165         RESULT setNextPlaybackFile(const char *fn);
 166
 167                 // iCueSheet
 168         PyObject *getCutList();
 169         void setCutList(SWIG_PYOBJECT(ePyObject));
 170         void setCutListEnable(int enable);
 171
 172                 // iSubtitleOutput
 173         RESULT enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) entry);
 174         RESULT disableSubtitles(eWidget *parent);
 175         PyObject *getSubtitleList();
 176         PyObject *getCachedSubtitle();
 177
 178                 // iAudioDelay
 179         int getAC3Delay();
 180         int getPCMDelay();
 181         void setAC3Delay(int);
 182         void setPCMDelay(int);
 183
 184                 // iStreamableService
 185         RESULT stream(ePtr<iStreamableService> &ptr);
 186         PyObject *getStreamingData();
 187         void setQpipMode(bool value, bool audio);
 188
 189 protected:
 190         friend class eServiceFactoryDVB;
 191         eServiceReference m_reference;
 192
 193         ePtr<eDVBService> m_dvb_service;
 194
 195         ePtr<iTSMPEGDecoder> m_decoder;
 196         int m_decoder_index;
 197         int m_is_primary;
 198         int m_have_video_pid;
 199         int m_tune_state;
 200
 201                 /* in timeshift mode, we essentially have two channels, and thus pmt handlers. */
 202         eDVBServicePMTHandler m_service_handler_timeshift;
 203         eDVBServiceEITHandler m_event_handler;
 204         int m_current_audio_pid;
 205         int m_current_video_pid_type;
 206
 207         bool m_qpip_mode;
 208         bool m_play_audio;
 209
 210         eDVBServicePlay(const eServiceReference &ref, eDVBService *service, bool connect_event=true);
 211
 212                 /* events */
 213         void gotNewEvent();
 214
 215         void serviceEvent(int event);
 216         void serviceEventTimeshift(int event);
 217         Signal2<void,iPlayableService*,int> m_event;
 218
 219         int m_is_stream;
 220
 221                 /* pvr */
 222         int m_is_pvr, m_is_paused, m_timeshift_enabled, m_timeshift_active, m_timeshift_changed;
 223         int m_first_program_info;
 224
 225         std::string m_timeshift_file, m_timeshift_file_next;
 226         int m_timeshift_fd;
 227         ePtr<iDVBDemux> m_decode_demux;
 228
 229         int m_current_audio_stream;
 230         int selectAudioStream(int n = -1);
 231         RESULT setFastForward_internal(int ratio, bool final_seek=false);
 232
 233                 /* timeshift */
 234         ePtr<iDVBTSRecorder> m_record;
 235         std::set<int> m_pids_active;
 236
 237         void updateTimeshiftPids();
 238         virtual void switchToLive();
 239
 240         void resetTimeshift(int start);
 241         void switchToTimeshift();
 242
 243         void updateDecoder(bool sendSeekableStateChanged=false);
 244
 245         int m_skipmode;
 246         int m_fastforward;
 247         int m_slowmotion;
 248
 249                 /* cuesheet */
 250
 251         ePtr<eCueSheet> m_cue;
 252
 253         struct cueEntry
 254         {
 255                 pts_t where;
 256                 unsigned int what;
 257
 258                 bool operator < (const struct cueEntry &o) const
 259                 {
 260                         return where < o.where;
 261                 }
 262                 cueEntry(const pts_t &where, unsigned int what) :
 263                         where(where), what(what)
 264                 {
 265                 }
 266         };
 267
 268         std::multiset<cueEntry> m_cue_entries;
 269         int m_cuesheet_changed, m_cutlist_enabled;
 270
 271         void loadCuesheet();
 272         void saveCuesheet();
 273
 274         void cutlistToCuesheet();
 275
 276         eSubtitleWidget *m_subtitle_widget;
 277
 278                 /* teletext subtitles */
 279         ePtr<eDVBTeletextParser> m_teletext_parser;
 280         void newSubtitlePage(const eDVBTeletextSubtitlePage &p);
 281         ePtr<eConnection> m_new_subtitle_page_connection;
 282         std::list<eDVBTeletextSubtitlePage> m_subtitle_pages;
 283
 284                 /* dvb subtitles */
 285         ePtr<eDVBSubtitleParser> m_subtitle_parser;
 286         void newDVBSubtitlePage(const eDVBSubtitlePage &p);
 287         ePtr<eConnection> m_new_dvb_subtitle_page_connection;
 288         std::list<eDVBSubtitlePage> m_dvb_subtitle_pages;
 289
 290         ePtr<eTimer> m_subtitle_sync_timer;
 291         void checkSubtitleTiming();
 292
 293                 /* radiotext */
 294         ePtr<eDVBRdsDecoder> m_rds_decoder;
 295         ePtr<eConnection> m_rds_decoder_event_connection;
 296         void rdsDecoderEvent(int);
 297
 298         ePtr<eConnection> m_video_event_connection;
 299         void video_event(struct iTSMPEGDecoder::videoEvent);
 300
 301         virtual ePtr<iTsSource> createTsSource(eServiceReferenceDVB &ref);
 302 };
 303
 304 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
 305 {
 306         DECLARE_REF(eStaticServiceDVBBouquetInformation);
 307         eServiceReference m_playable_service;
 308 public:
 309         eServiceReference &getPlayableService() { return m_playable_service; }
 310         RESULT getName(const eServiceReference &ref, std::string &name);
 311         int getLength(const eServiceReference &ref);
 312         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate=false);
 313         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time);
 314 };
 315
 316 #endif