source: titan/titan/dmxdev.h @ 24101

Last change on this file since 24101 was 23206, checked in by nit, 11 years ago

[titan] revert

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