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