prepare for dvb subtitle support (not finished yet)
[enigma2.git] / 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         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 class eDVBServiceBase: public iFrontendInformation
67 {
68 protected:
69         eDVBServicePMTHandler m_service_handler ;
70 public:
71                 // iFrontendInformation
72         int getFrontendInfo(int w);
73         PyObject *getFrontendData(bool);
74 };
75
76 class eSubtitleWidget; 
77
78 class eDVBServicePlay: public eDVBServiceBase,
79                 public iPlayableService, public iPauseableService, 
80                 public iSeekableService, public Object, public iServiceInformation, 
81                 public iAudioTrackSelection, public iAudioChannelSelection,
82                 public iSubserviceList, public iTimeshiftService,
83                 public iCueSheet, public iSubtitleOutput, public iAudioDelay,
84                 public iRadioText
85 {
86 DECLARE_REF(eDVBServicePlay);
87 public:
88         virtual ~eDVBServicePlay();
89
90                 // iPlayableService
91         RESULT connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection);
92         RESULT start();
93         RESULT stop();
94         RESULT setTarget(int target);
95         
96         RESULT seek(ePtr<iSeekableService> &ptr);
97         RESULT pause(ePtr<iPauseableService> &ptr);
98         RESULT info(ePtr<iServiceInformation> &ptr);
99         RESULT audioChannel(ePtr<iAudioChannelSelection> &ptr);
100         RESULT audioTracks(ePtr<iAudioTrackSelection> &ptr);
101         RESULT frontendInfo(ePtr<iFrontendInformation> &ptr);
102         RESULT subServices(ePtr<iSubserviceList> &ptr);
103         RESULT timeshift(ePtr<iTimeshiftService> &ptr);
104         RESULT cueSheet(ePtr<iCueSheet> &ptr);
105         RESULT subtitle(ePtr<iSubtitleOutput> &ptr);
106         RESULT audioDelay(ePtr<iAudioDelay> &ptr);
107         RESULT radioText(ePtr<iRadioText> &ptr);
108
109                 // iPauseableService
110         RESULT pause();
111         RESULT unpause();
112         RESULT setSlowMotion(int ratio);
113         RESULT setFastForward(int ratio);
114         
115                 // iSeekableService
116         RESULT getLength(pts_t &len);
117         RESULT seekTo(pts_t to);
118         RESULT seekRelative(int direction, pts_t to);
119         RESULT getPlayPosition(pts_t &pos);
120         RESULT setTrickmode(int trick=0);
121         RESULT isCurrentlySeekable();
122
123                 // iServiceInformation
124         RESULT getName(std::string &name);
125         RESULT getEvent(ePtr<eServiceEvent> &evt, int nownext);
126         int getInfo(int w);
127         std::string getInfoString(int w);
128         PyObject *getInfoObject(int w);
129
130                 // iAudioTrackSelection 
131         int getNumberOfTracks();
132         RESULT selectTrack(unsigned int i);
133         RESULT getTrackInfo(struct iAudioTrackInfo &, unsigned int n);
134
135                 // iAudioChannelSelection       
136         int getCurrentChannel();
137         RESULT selectChannel(int i);
138
139                 // iRadioText
140         std::string getRadioText(int i=0);
141
142                 // iSubserviceList
143         int getNumberOfSubservices();
144         RESULT getSubservice(eServiceReference &subservice, unsigned int n);
145
146                 // iTimeshiftService
147         RESULT startTimeshift();
148         RESULT stopTimeshift();
149         int isTimeshiftActive();
150         RESULT activateTimeshift();
151
152                 // iCueSheet
153         PyObject *getCutList();
154         void setCutList(PyObject *);
155         void setCutListEnable(int enable);
156         
157                 // iSubtitleOutput
158         RESULT enableSubtitles(eWidget *parent, PyObject *entry);
159         RESULT disableSubtitles(eWidget *parent);
160         PyObject *getSubtitleList();
161
162                 // iAudioDelay
163         int getAC3Delay();
164         int getPCMDelay();
165         void setAC3Delay(int);
166         void setPCMDelay(int);
167
168 private:
169         friend class eServiceFactoryDVB;
170         eServiceReference m_reference;
171         
172         ePtr<eDVBService> m_dvb_service;
173         
174         ePtr<iTSMPEGDecoder> m_decoder;
175         int m_is_primary;
176         int m_have_video_pid;
177         
178                 /* in timeshift mode, we essentially have two channels, and thus pmt handlers. */
179         eDVBServicePMTHandler m_service_handler_timeshift;
180         eDVBServiceEITHandler m_event_handler;
181         
182         eDVBServicePlay(const eServiceReference &ref, eDVBService *service);
183         
184                 /* events */
185         void gotNewEvent();
186         
187         void serviceEvent(int event);
188         void serviceEventTimeshift(int event);
189         Signal2<void,iPlayableService*,int> m_event;
190         
191                 /* pvr */
192         int m_is_pvr, m_is_paused, m_timeshift_enabled, m_timeshift_active;
193         int m_first_program_info;
194         
195         std::string m_timeshift_file;
196         int m_timeshift_fd;
197         
198         ePtr<iDVBDemux> m_decode_demux;
199
200         int m_current_audio_stream;
201         int selectAudioStream(int n);
202         
203                 /* timeshift */
204         ePtr<iDVBTSRecorder> m_record;
205         std::set<int> m_pids_active;
206
207         void updateTimeshiftPids();
208         void switchToLive();
209         void switchToTimeshift();
210         
211         void updateDecoder();
212         
213         int m_skipmode;
214         
215                 /* cuesheet */
216         
217         ePtr<eCueSheet> m_cue;
218         
219         struct cueEntry
220         {
221                 pts_t where;
222                 unsigned int what;
223                 
224                 bool operator < (const struct cueEntry &o) const
225                 {
226                         return where < o.where;
227                 }
228                 cueEntry(const pts_t &where, unsigned int what) :
229                         where(where), what(what)
230                 {
231                 }
232         };
233         
234         std::multiset<cueEntry> m_cue_entries;
235         int m_cuesheet_changed, m_cutlist_enabled;
236         
237         void loadCuesheet();
238         void saveCuesheet();
239         
240         void cutlistToCuesheet();
241         
242         eSubtitleWidget *m_subtitle_widget;
243         
244                 /* teletext subtitles */
245         ePtr<eDVBTeletextParser> m_teletext_parser;
246         void newSubtitlePage(const eDVBTeletextSubtitlePage &p);
247         ePtr<eConnection> m_new_subtitle_page_connection;
248         eTimer m_subtitle_sync_timer;
249         std::list<eDVBTeletextSubtitlePage> m_subtitle_pages;
250         void checkSubtitleTiming();
251         
252                 /* dvb subtitles */
253         void newDVBSubtitleRegion(const eDVBSubtitleRegion &p);
254         ePtr<eConnection> m_new_dvb_subtitle_region_connection;
255         eTimer m_dvb_subtitle_sync_timer;
256         std::list<eDVBSubtitleRegion> m_dvb_subtitle_regions;
257         void checkDvbSubtitleTiming();
258
259                 /* radiotext */
260         ePtr<eDVBRadioTextParser> m_radiotext_parser;
261         ePtr<eConnection> m_radiotext_updated_connection;
262         void radioTextUpdated();
263 };
264
265 #endif