source: titan/titan/dmxdev.h @ 15272

Last change on this file since 15272 was 14216, checked in by nit, 12 years ago

[titan] aktivate nit scan
File size: 9.4 KB
Line 
1#ifndef DMXDEV_H
2#define DMXDEV_H
3
4#if DVB_API_VERSION > 3
5#ifndef DMX_ADD_PID
6#define DMX_ADD_PID             _IOW('o', 51, __u16)
7#define DMX_REMOVE_PID          _IOW('o', 52, __u16)
8#endif
9#else
10#define DMX_ADD_PID              _IO('o', 51)
11#define DMX_REMOVE_PID           _IO('o', 52)
12#endif
13
14struct dvbdev* dmxgetlast(int adapter)
15{
16        struct dvbdev* node = dvbdev;
17        struct dvbdev* lastnode = NULL;
18
19        while(node != NULL)
20        {
21                if(node->type == DEMUXDEV && node->adapter == adapter)
22                        lastnode = node;
23                node = node->next;
24        }
25
26        return lastnode;
27}
28
29struct dvbdev* dmxopen(struct dvbdev* fenode)
30{
31        debug(1000, "in");
32        int fd = -1;
33        struct dvbdev* node = dvbdev;
34
35        if(fenode == NULL) return NULL;
36               
37        m_lock(&status.dmxdevmutex, 9);
38       
39        while(node != NULL)
40        {
41                if(node->fd == -1 && node->type == DEMUXDEV && node->adapter == fenode->adapter && node->devnr == fenode->devnr)
42                        break;
43                node = node->next;
44        }
45
46        if(node != NULL)
47        {
48                if((fd = open(node->dev, O_RDWR)) < 0)
49                {
50                        debug(200, "open dmx failed %s", node->dev);
51                        node = NULL;
52                }
53                else
54                {
55                        fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
56                        node->fd = fd;
57                        closeonexec(fd);
58                }
59        }
60
61        m_unlock(&status.dmxdevmutex, 9);
62        debug(1000, "out");
63        return node;
64}
65
66int dmxopendirect(char *dmxdev)
67{
68        debug(1000, "in");
69        int fd = -1;
70       
71        if((fd = open(dmxdev, O_RDWR)) < 0)
72        {
73                debug(200, "open dmx failed %s", dmxdev);
74        }
75        else
76                fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
77       
78        closeonexec(fd);
79        debug(1000, "out");
80        return fd;
81}
82
83void dmxclose(struct dvbdev* node, int fd)
84{
85        if(node != NULL)
86        {
87                close(node->fd);
88                node->fd = -1;
89        }
90        else
91                close(fd);
92}
93
94int dmxstop(struct dvbdev* node)
95{
96        if(node == NULL)
97        {
98                debug(1000, "out-> NULL detect");
99                return 1;
100        }
101
102        if(ioctl(node->fd, DMX_STOP) < 0)
103        {
104                perr("DMX_STOP");
105                return 1;
106        }
107       
108        return 0;
109}
110
111int dmxstart(struct dvbdev* node)
112{
113        if(node == NULL)
114        {
115                debug(1000, "out-> NULL detect");
116                return 1;
117        }
118
119        if(ioctl(node->fd, DMX_START) < 0)
120        {
121                perr("DMX_START");
122                return 1;
123        }
124       
125        return 0;
126}
127
128int dmxsetbuffersize(struct dvbdev* node, unsigned long size)
129{
130        if(node == NULL)
131        {
132                debug(1000, "out-> NULL detect");
133                return 1;
134        }
135
136        if(size == 0)
137                size = getconfigint("dmxvideobuffersize", NULL);
138
139        debug(200, "DMX_SET_BUFFER_SIZE=%ld", size);
140        if(ioctl(node->fd, DMX_SET_BUFFER_SIZE, size) < 0)
141        {
142                perr("DMX_SET_BUFFER_SIZE");
143                return 1;
144        }
145       
146        return 0;
147}
148
149int dmxsetfilter(struct dvbdev* node, int pid, int secnr, int flag)
150{
151        struct dmx_sct_filter_params sctflt;
152
153        if(node == NULL)
154        {
155                debug(1000, "out-> NULL detect");
156                return 1;
157        }
158
159        memset(&sctflt, 0, sizeof(sctflt));
160
161        if(flag == 1) //pat filter
162        {
163                sctflt.timeout = 0;
164                sctflt.pid = pid;
165                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
166        }
167        if(flag == 2)  //pmt filter
168        {
169                sctflt.filter.filter[0] = 0x02;
170                sctflt.filter.mask[0] = 0xff;
171                sctflt.timeout = 0;
172                sctflt.pid = pid;
173                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
174        }
175        if(flag == 3)  //date filter
176        {
177                sctflt.filter.filter[0] = 0x70;
178                sctflt.filter.mask[0] = 0xff;
179                sctflt.timeout = 0;
180                sctflt.pid = pid;
181                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
182        }
183        if(flag == 4)  //nit filter (pid 0x10)
184        {
185                sctflt.filter.filter[0] = 0x40;
186                sctflt.filter.mask[0] = 0xff;
187                sctflt.filter.filter[1] = 0x00;
188                sctflt.filter.mask[1] = 0x00;
189                sctflt.filter.filter[2] = 0x00;
190                sctflt.filter.mask[2] = 0x00;
191                sctflt.filter.filter[3] = 0x00;
192                sctflt.filter.mask[3] = 0x00;
193                sctflt.filter.filter[4] = secnr;
194                sctflt.filter.mask[4] = 0xff;
195                sctflt.timeout = 0;
196                sctflt.pid = pid;
197                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
198        }
199        if(flag == 5)  //eit all filter (pid 0x12)
200        {
201                sctflt.filter.filter[0] = 0x40;
202                sctflt.filter.mask[0] = 0x40;
203                sctflt.timeout = 0;
204                sctflt.pid = pid;
205                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
206        }
207        if(flag == 6) //eit schedule, current multiplex (pid 0x12)
208        {
209                sctflt.filter.filter[0] = 0x50;
210                sctflt.filter.mask[0] = 0xf0;
211                sctflt.timeout = 0;
212                sctflt.pid = pid;
213                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
214        }
215        if(flag == 7) //eit schedule, other multiplex (pid 0x12)
216        {
217                sctflt.filter.filter[0] = 0x60;
218                sctflt.filter.mask[0] = 0xf0;
219                sctflt.timeout = 0;
220                sctflt.pid = pid;
221                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
222        }
223        if(flag == 8)  //eit now/next only filter (pid 0x12)
224        {
225                sctflt.filter.filter[0] = 0x4e;
226                sctflt.filter.mask[0] = 0xfe;
227                sctflt.timeout = 0;
228                sctflt.pid = pid;
229                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
230        }
231        if(flag == 9)  //eit now/next current multiplex (pid 0x12)
232        {
233                sctflt.filter.filter[0] = 0x4e;
234                sctflt.filter.mask[0] = 0xff;
235                sctflt.timeout = 0;
236                sctflt.pid = pid;
237                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
238        }
239        if(flag == 10)  //eit now/next other multiplex (pid 0x12)
240        {
241                sctflt.filter.filter[0] = 0x4f;
242                sctflt.filter.mask[0] = 0xff;
243                sctflt.timeout = 0;
244                sctflt.pid = pid;
245                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
246        }
247        if(flag == 11)  //sdt akt (pid 0x11)
248        {
249                sctflt.filter.filter[0] = 0x42;
250                sctflt.filter.mask[0] = 0xff;
251                sctflt.filter.filter[1] = 0x00;
252                sctflt.filter.mask[1] = 0x00;
253                sctflt.filter.filter[2] = 0x00;
254                sctflt.filter.mask[2] = 0x00;
255                sctflt.filter.filter[3] = 0x00;
256                sctflt.filter.mask[3] = 0x00;
257                sctflt.filter.filter[4] = secnr;
258                sctflt.filter.mask[4] = 0xff;
259                sctflt.timeout = 0;
260                sctflt.pid = pid;
261                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
262        }
263        if(flag == 12)  //sdt other (pid 0x11)
264        {
265                sctflt.filter.filter[0] = 0x46;
266                sctflt.filter.mask[0] = 0xff;
267                sctflt.filter.filter[1] = 0x00;
268                sctflt.filter.mask[1] = 0x00;
269                sctflt.filter.filter[2] = 0x00;
270                sctflt.filter.mask[2] = 0x00;
271                sctflt.filter.filter[3] = 0x00;
272                sctflt.filter.mask[3] = 0x00;
273                sctflt.filter.filter[4] = secnr;
274                sctflt.filter.mask[4] = 0xff;
275                sctflt.timeout = 0;
276                sctflt.pid = pid;
277                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
278        }
279        if(flag == 13)  //rst filter (pid 0x13)
280        {
281                sctflt.filter.filter[0] = 0x13;
282                sctflt.filter.mask[0] = 0xff;
283                sctflt.timeout = 0;
284                sctflt.pid = pid;
285                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
286        }
287
288        debug(200, "DMX_SET_FILTER pid=%d, flag=%d", pid, flag);
289        if(ioctl(node->fd, DMX_SET_FILTER, &sctflt) < 0)
290        {
291                perr("DMX_SET_FILTER");
292                return 1;
293        }
294
295        return 0;
296}
297
298int dmxaddpid(struct dvbdev* node, int pid)
299{
300        if(node == NULL)
301        {
302                debug(1000, "out-> NULL detect");
303                return 1;
304        }
305
306        debug(200, "DMX_ADD_PID=%d", pid);
307        while(1)
308        {
309#if DVB_API_VERSION > 3
310                __u16 p = pid;
311                if(ioctl(node->fd, DMX_ADD_PID, &p) < 0)
312#else
313                if(ioctl(node->fd, DMX_ADD_PID, pid) < 0)
314#endif
315                {
316                        perr("DMX_ADD_PID");
317                        if(errno == EAGAIN || errno == EINTR)
318                                continue;
319                        return 1;
320                }
321                break;
322        }
323
324        return 0;
325}
326
327int dmxremovepid(struct dvbdev* node, int pid)
328{
329        if(node == NULL)
330        {
331                debug(1000, "out-> NULL detect");
332                return 1;
333        }
334
335        debug(200, "DMX_REMOVE_PID=%d", pid);
336        while(1)
337        {
338#if DVB_API_VERSION > 3
339                __u16 p = pid;
340                if(ioctl(node->fd, DMX_REMOVE_PID, &p) < 0)
341#else
342                if(ioctl(node->fd, DMX_REMOVE_PID, pid) < 0)
343#endif
344                {
345                        perr("DMX_REMOVE_PID");
346                        if(errno == EAGAIN || errno == EINTR)
347                                continue;
348                        return 1;
349                }
350                break;
351        }
352
353        return 0;
354}
355
356int dmxgetstc(struct dvbdev* node, int64_t* stc)
357{
358        struct dmx_stc dmxstc;
359
360        if(node == NULL)
361        {
362                debug(1000, "out-> NULL detect");
363                return 1;
364        }
365
366        memset(&dmxstc, 0, sizeof(struct dmx_stc));
367        dmxstc.num = 0;
368        dmxstc.base = 1;
369
370        debug(200, "DMX_GET_STC");
371        if(ioctl(node->fd, DMX_GET_STC, &dmxstc) < 0)
372        {
373                perr("DMX_GET_STC");
374                return 1;
375        }
376        else
377                *stc = (int64_t)dmxstc.stc;
378
379        return 0;
380}
381
382int dmxsetsource(struct dvbdev* node, int source)
383{
384        if(node == NULL)
385        {
386                debug(1000, "out-> NULL detect");
387                return 1;
388        }
389
390        debug(200, "DMX_SET_SOURCE=%d", source);
391        if(ioctl(node->fd, DMX_SET_SOURCE, &source) < 0)
392        {
393                perr("DMX_SET_SOURCE");
394        }
395
396        return 0;
397}
398
399int dmxsetpesfilterfd(int fd, int pid, int input, int output, int pestype, int nostart)
400{
401        struct dmx_pes_filter_params pesflt;
402        memset(&pesflt, 0, sizeof(pesflt));
403
404        if(input == -1)
405        {
406                if(status.playing == 1)
407                        pesflt.input = DMX_IN_DVR;
408                else
409                        pesflt.input = DMX_IN_FRONTEND;
410        }
411        else
412                pesflt.input = input;
413
414        pesflt.output = output;
415        pesflt.pid = pid;
416        if(nostart == 0)
417                pesflt.flags = DMX_IMMEDIATE_START;
418        pesflt.pes_type = pestype;
419
420        debug(200, "DMX_SET_PES_FILTER pid=%d, pestype=%d, input=%d, output=%d", pid, pestype, pesflt.input, output);
421        if(ioctl(fd, DMX_SET_PES_FILTER, &pesflt) < 0)
422        {
423                perr("DMX_SET_PES_FILTER");
424                return 1;
425        }
426
427        return 0;
428}
429
430int dmxsetpesfilter(struct dvbdev* node, int pid, int input, int output, int pestype, int nostart)
431{
432        if(node == NULL)
433        {
434                debug(1000, "out-> NULL detect");
435                return 1;
436        }
437        return dmxsetpesfilterfd(node->fd, pid, input, output, pestype, nostart);
438}
439
440int dmxgetdev()
441{
442        debug(1000, "in");
443        int i, y, z, fd = -1, count = 0;
444        char *buf = NULL, *dmxdev = NULL;
445
446        dmxdev = getconfig("dmxdev", NULL);
447        if(dmxdev == NULL)
448        {
449                debug(1000, "out -> NULL detect");
450                return count;
451        }
452
453        buf = malloc(MINMALLOC);
454        if(buf == NULL)
455        {
456                err("no memory");
457                return count;
458        }
459
460        for(i = 0; i < MAXDVBADAPTER; i++)
461        {
462                for(y = 0; y < MAXDEMUXDEV; y++)
463                {
464                        sprintf(buf, dmxdev, i, y);
465                        fd = dmxopendirect(buf);
466                        if(fd >= 0)
467                        {
468                                count++;
469                                for(z = 0; z < MAXDEMUXDEVOPEN; z++)
470                                        adddvbdev(buf, i, y, -1, DEMUXDEV, NULL, NULL);
471                                //without this, on atevio7500, if the second tuner is the maintuner
472                                //no picture (i don't know why)
473                                dmxsetpesfilterfd(fd, 0, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0);
474                                dmxclose(NULL, fd);
475                        }
476                }
477        }
478
479        free(buf);
480        debug(1000, "out");
481        return count;
482}
483
484#endif
Note: See TracBrowser for help on using the repository browser.