remove unneeded signals ( eDVBChannel::m_stateChanged give us the same informations )
[enigma2.git] / lib / dvb / demux.cpp
1 #include <config.h>
2 #include <stdio.h>
3 #include <fcntl.h>
4 #include <sys/ioctl.h>
5 #include <errno.h>
6 #include <unistd.h>
7 #include <signal.h>
8
9 #include <lib/base/thread.h>
10
11 #if HAVE_DVB_API_VERSION < 3
12 #include <ost/dmx.h>
13 #ifndef DMX_SET_NEGFILTER_MASK
14         #define DMX_SET_NEGFILTER_MASK   _IOW('o',48,uint8_t *)
15 #endif
16 #else
17 #include <linux/dvb/dmx.h>
18 #endif
19
20 #include "crc32.h"
21
22 #include <lib/base/eerror.h>
23 #include <lib/dvb/idvb.h>
24 #include <lib/dvb/demux.h>
25 #include <lib/dvb/esection.h>
26 #include <lib/dvb/decoder.h>
27
28 eDVBDemux::eDVBDemux(int adapter, int demux): adapter(adapter), demux(demux)
29 {
30         m_dvr_busy = 0;
31 }
32
33 eDVBDemux::~eDVBDemux()
34 {
35 }
36
37 DEFINE_REF(eDVBDemux)
38
39 RESULT eDVBDemux::createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)
40 {
41         RESULT res;
42         reader = new eDVBSectionReader(this, context, res);
43         if (res)
44                 reader = 0;
45         return res;
46 }
47
48 RESULT eDVBDemux::createTSRecorder(ePtr<iDVBTSRecorder> &recorder)
49 {
50         if (m_dvr_busy)
51                 return -EBUSY;
52         recorder = new eDVBTSRecorder(this);
53         return 0;
54 }
55
56 RESULT eDVBDemux::getMPEGDecoder(ePtr<iTSMPEGDecoder> &decoder)
57 {
58         decoder = new eTSMPEGDecoder(this, 0);
59         return 0;
60 }
61
62 void eDVBSectionReader::data(int)
63 {
64         __u8 data[4096]; // max. section size
65         int r;
66         r = ::read(fd, data, 4096);
67         if(r < 0)
68         {
69                 eWarning("ERROR reading section - %m\n");
70                 return;
71         }
72         if (checkcrc)
73         {
74                         // this check should never happen unless the driver is crappy!
75                 unsigned int c;
76                 if ((c = crc32((unsigned)-1, data, r)))
77                         eFatal("crc32 failed! is %x\n", c);
78         }
79         if (active)
80                 read(data);
81         else
82                 eDebug("data.. but not active");
83 }
84
85 eDVBSectionReader::eDVBSectionReader(eDVBDemux *demux, eMainloop *context, RESULT &res): demux(demux)
86 {
87         char filename[128];
88 #if HAVE_DVB_API_VERSION < 3
89         sprintf(filename, "/dev/dvb/card%d/demux%d", demux->adapter, demux->demux);
90 #else
91         sprintf(filename, "/dev/dvb/adapter%d/demux%d", demux->adapter, demux->demux);
92 #endif
93         fd = ::open(filename, O_RDWR);
94         
95         eDebug("eDVBSectionReader has fd %d", fd);
96         
97         if (fd >= 0)
98         {
99                 notifier=new eSocketNotifier(context, fd, eSocketNotifier::Read);
100                 CONNECT(notifier->activated, eDVBSectionReader::data);
101                 res = 0;
102         } else
103         {
104                 perror(filename);
105                 res = errno;
106         }
107 }
108
109 DEFINE_REF(eDVBSectionReader)
110
111 eDVBSectionReader::~eDVBSectionReader()
112 {
113         if (notifier)
114                 delete notifier;
115         if (fd >= 0)
116                 ::close(fd);
117 }
118
119 RESULT eDVBSectionReader::start(const eDVBSectionFilterMask &mask)
120 {
121         RESULT res;
122         if (fd < 0)
123                 return -ENODEV;
124
125 #if HAVE_DVB_API_VERSION < 3
126         dmxSctFilterParams sct;
127 #else
128         dmx_sct_filter_params sct;
129 #endif
130         sct.pid     = mask.pid;
131         sct.timeout = 0;
132 #if HAVE_DVB_API_VERSION < 3
133         sct.flags   = 0;
134 #else
135         sct.flags   = DMX_IMMEDIATE_START;
136 #endif
137         if (mask.flags & eDVBSectionFilterMask::rfCRC)
138         {
139                 sct.flags |= DMX_CHECK_CRC;
140                 checkcrc = 1;
141         } else
142                 checkcrc = 0;
143         
144         memcpy(sct.filter.filter, mask.data, DMX_FILTER_SIZE);
145         memcpy(sct.filter.mask, mask.mask, DMX_FILTER_SIZE);
146 #if HAVE_DVB_API_VERSION >= 3
147         memcpy(sct.filter.mode, mask.mode, DMX_FILTER_SIZE);
148 #endif
149         
150         res = ::ioctl(fd, DMX_SET_FILTER, &sct);
151         if (!res)
152         {
153 #if HAVE_DVB_API_VERSION < 3
154                 res = ::ioctl(fd, DMX_SET_NEGFILTER_MASK, mask.mode);
155                 if (!res)
156                 {
157                         res = ::ioctl(fd, DMX_START, 0);
158                         if (!res)
159                                 active = 1;
160                 }
161 #else
162                 active = 1;
163 #endif
164         }
165         return res;
166 }
167
168 RESULT eDVBSectionReader::stop()
169 {
170         if (!active)
171                 return -1;
172
173         active=0;
174         ::ioctl(fd, DMX_STOP);
175         
176         return 0;
177 }
178
179 RESULT eDVBSectionReader::connectRead(const Slot1<void,const __u8*> &r, ePtr<eConnection> &conn)
180 {
181         conn = new eConnection(this, read.connect(r));
182         return 0;
183 }
184
185 DEFINE_REF(eDVBTSRecorder);
186
187 class eDVBTSRecorderThread: public eThread
188 {
189 public:
190         eDVBTSRecorderThread();
191         void thread();
192         void stop();
193         void start(int sourcefd, int destfd);
194 private:
195         int m_stop;
196         unsigned char m_buffer[65536];
197         int m_buf_start, m_buf_end;
198         int m_fd_source, m_fd_dest;
199 };
200
201 eDVBTSRecorderThread::eDVBTSRecorderThread()
202 {
203         m_stop = 0;
204         m_buf_start = m_buf_end = 0;
205 }
206
207 static void signal_handler(int x)
208 {
209 }
210
211 void eDVBTSRecorderThread::thread()
212 {
213         eDebug("RECORDING THREAD START");
214                 // this is race. FIXME.
215         
216                 /* we set the signal to not restart syscalls, so we can detect our signal. */
217         struct sigaction act;
218         act.sa_handler = signal_handler; // no, SIG_IGN doesn't do it :/
219         act.sa_flags = 0;
220         sigaction(SIGUSR1, &act, 0);
221         
222                 /* m_stop must be evaluated after each syscall. */
223         while (!m_stop)
224         {
225                         /* first try flushing the bufptr */
226                 if (m_buf_start != m_buf_end)
227                 {
228                                 // TODO: take care of boundaries.
229                         int w = write(m_fd_dest, m_buffer + m_buf_start, m_buf_end - m_buf_start);
230                         if (w <= 0)
231                         {
232                                 if (errno == -EINTR)
233                                         continue;
234                                 eDebug("eDVBTSRecorder *write error* - not yet handled");
235                                 // ... we would stop the thread
236                         }
237                         printf("TSRECORD: wrote %d bytes\n", w);
238                         m_buf_start += w;
239                         continue;
240                 }
241                         
242                         /* now fill our buffer. */
243                 m_buf_start = 0;
244                 m_buf_end = read(m_fd_source, m_buffer, sizeof(m_buffer));
245                 if (m_buf_end < 0)
246                 {
247                         m_buf_end = 0;
248                         if (errno == EINTR)
249                                 continue;
250                         eDebug("eDVBTSRecorder *read error* - not yet handled");
251                 }
252                 printf("TSRECORD: read %d bytes\n", m_buf_end);
253         }
254         
255         eDebug("RECORDING THREAD STOP");
256 }
257
258 void eDVBTSRecorderThread::start(int fd_source, int fd_dest)
259 {
260         m_fd_source = fd_source;
261         m_fd_dest = fd_dest;
262         m_stop = 0;
263         run();
264 }
265
266 void eDVBTSRecorderThread::stop()
267 {
268         m_stop = 1;
269         sendSignal(SIGUSR1);
270         kill();
271 }
272
273 eDVBTSRecorder::eDVBTSRecorder(eDVBDemux *demux): m_demux(demux)
274 {
275         m_running = 0;
276         m_format = 0;
277         m_target_fd = -1;
278         m_thread = new eDVBTSRecorderThread();
279         m_demux->m_dvr_busy = 1;
280 }
281
282 eDVBTSRecorder::~eDVBTSRecorder()
283 {
284         stop();
285         delete m_thread;
286         m_demux->m_dvr_busy = 0;
287 }
288
289 RESULT eDVBTSRecorder::start()
290 {
291         if (m_running)
292                 return -1;
293         
294         if (m_target_fd == -1)
295                 return -2;
296                 
297         char filename[128];
298 #if HAVE_DVB_API_VERSION < 3
299         snprintf(filename, 128, "/dev/dvb/card%d/dvr%d", m_demux->adapter, m_demux->demux);
300 #else
301         snprintf(filename, 128, "/dev/dvb/adapter%d/dvr%d", m_demux->adapter, m_demux->demux);
302 #endif
303         m_source_fd = ::open(filename, O_RDONLY);
304         
305         if (m_source_fd < 0)
306         {
307                 eDebug("FAILED to open dvr (%s) in ts recoder (%m)", filename);
308                 return -3;
309         }
310         
311         m_thread->start(m_source_fd, m_target_fd);
312         m_running = 1;
313         
314         for (std::map<int,int>::iterator i(m_pids.begin()); i != m_pids.end(); ++i)
315                 startPID(i->first);
316         
317         return 0;
318 }
319
320 RESULT eDVBTSRecorder::addPID(int pid)
321 {
322         if (m_pids.find(pid) != m_pids.end())
323                 return -1;
324         
325         m_pids.insert(std::pair<int,int>(pid, -1));
326         if (m_running)
327                 startPID(pid);
328         return 0;
329 }
330
331 RESULT eDVBTSRecorder::removePID(int pid)
332 {
333         if (m_pids.find(pid) == m_pids.end())
334                 return -1;
335                 
336         if (m_running)
337                 stopPID(pid);
338         
339         m_pids.erase(pid);
340         return 0;
341 }
342
343 RESULT eDVBTSRecorder::setFormat(int format)
344 {
345         if (m_running)
346                 return -1;
347         m_format = format;
348         return 0;
349 }
350
351 RESULT eDVBTSRecorder::setTargetFD(int fd)
352 {
353         m_target_fd = fd;
354         return 0;
355 }
356
357 RESULT eDVBTSRecorder::setBoundary(off_t max)
358 {
359         return -1; // not yet implemented
360 }
361
362 RESULT eDVBTSRecorder::stop()
363 {
364         for (std::map<int,int>::iterator i(m_pids.begin()); i != m_pids.end(); ++i)
365                 stopPID(i->first);
366
367         if (!m_running)
368                 return -1;
369         m_thread->stop();
370         
371         close(m_source_fd);
372         
373         return 0;
374 }
375
376 RESULT eDVBTSRecorder::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn)
377 {
378         conn = new eConnection(this, m_event.connect(event));
379         return 0;
380 }
381
382 RESULT eDVBTSRecorder::startPID(int pid)
383 {
384         char filename[128];
385 #if HAVE_DVB_API_VERSION < 3
386         snprintf(filename, 128, "/dev/dvb/card%d/demux%d", m_demux->adapter, m_demux->demux);
387 #else
388         snprintf(filename, 128, "/dev/dvb/adapter%d/demux%d", m_demux->adapter, m_demux->demux);
389 #endif
390         int fd = ::open(filename, O_RDWR);
391         if (fd < 0)
392         {
393                 eDebug("FAILED to open demux (%s) in ts recoder (%m)", filename);
394                 return -1;
395         }
396
397 #if HAVE_DVB_API_VERSION < 3
398         dmxPesFilterParams flt;
399         
400         flt.pesType = DMX_PES_OTHER;
401 #else
402         dmx_pes_filter_params flt;
403         
404         flt.pes_type = DMX_PES_OTHER;
405 #endif
406
407         flt.pid     = pid;
408         flt.input   = DMX_IN_FRONTEND;
409         flt.output  = DMX_OUT_TS_TAP;
410         
411         flt.flags   = DMX_IMMEDIATE_START;
412
413         int res = ::ioctl(fd, DMX_SET_PES_FILTER, &flt);
414         if (res < 0)
415         {
416                 eDebug("set pes filter failed!");
417                 ::close(fd);
418                 return -1;
419         }
420         m_pids[pid] = fd;
421
422         return 0;
423 }
424
425 void eDVBTSRecorder::stopPID(int pid)
426 {
427         ::close(m_pids[pid]);
428         m_pids[pid] = -1;
429 }