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