source: titan/titan/dmxdev.h @ 34379

Last change on this file since 34379 was 31295, checked in by obi, 9 years ago

disable dmx work
File size: 11.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        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                // DMX_CHECK_CRC not working on mipsel
178                sctflt.flags = DMX_IMMEDIATE_START;// | DMX_CHECK_CRC;
179        }
180        if(flag == 4) //nit filter (pid 0x10)
181        {
182                sctflt.filter.filter[0] = 0x40;
183                sctflt.filter.mask[0] = 0xff;
184                sctflt.filter.filter[1] = 0x00;
185                sctflt.filter.mask[1] = 0x00;
186                sctflt.filter.filter[2] = 0x00;
187                sctflt.filter.mask[2] = 0x00;
188                sctflt.filter.filter[3] = 0x00;
189                sctflt.filter.mask[3] = 0x00;
190                sctflt.filter.filter[4] = secnr;
191                sctflt.filter.mask[4] = 0xff;
192                sctflt.timeout = 0;
193                sctflt.pid = pid;
194                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
195        }
196        if(flag == 5) //eit all filter (pid 0x12)
197        {
198                sctflt.filter.filter[0] = 0x40;
199                sctflt.filter.mask[0] = 0x40;
200                sctflt.timeout = 0;
201                sctflt.pid = pid;
202                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
203        }
204        if(flag == 6) //eit schedule, current multiplex (pid 0x12)
205        {
206                sctflt.filter.filter[0] = 0x50;
207                sctflt.filter.mask[0] = 0xf0;
208                sctflt.timeout = 0;
209                sctflt.pid = pid;
210                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
211        }
212        if(flag == 7) //eit schedule, other multiplex (pid 0x12)
213        {
214                sctflt.filter.filter[0] = 0x60;
215                sctflt.filter.mask[0] = 0xf0;
216                sctflt.timeout = 0;
217                sctflt.pid = pid;
218                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
219        }
220        if(flag == 8) //eit now/next only filter (pid 0x12)
221        {
222                sctflt.filter.filter[0] = 0x4e;
223                sctflt.filter.mask[0] = 0xfe;
224                sctflt.timeout = 0;
225                sctflt.pid = pid;
226                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
227        }
228        if(flag == 9) //eit now/next current multiplex (pid 0x12)
229        {
230                sctflt.filter.filter[0] = 0x4e;
231                sctflt.filter.mask[0] = 0xff;
232                sctflt.timeout = 0;
233                sctflt.pid = pid;
234                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
235        }
236        if(flag == 10) //eit now/next other multiplex (pid 0x12)
237        {
238                sctflt.filter.filter[0] = 0x4f;
239                sctflt.filter.mask[0] = 0xff;
240                sctflt.timeout = 0;
241                sctflt.pid = pid;
242                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
243        }
244        if(flag == 11) //sdt akt (pid 0x11)
245        {
246                sctflt.filter.filter[0] = 0x42;
247                sctflt.filter.mask[0] = 0xff;
248                sctflt.filter.filter[1] = 0x00;
249                sctflt.filter.mask[1] = 0x00;
250                sctflt.filter.filter[2] = 0x00;
251                sctflt.filter.mask[2] = 0x00;
252                sctflt.filter.filter[3] = 0x00;
253                sctflt.filter.mask[3] = 0x00;
254                sctflt.filter.filter[4] = secnr;
255                sctflt.filter.mask[4] = 0xff;
256                sctflt.timeout = 0;
257                sctflt.pid = pid;
258                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
259        }
260        if(flag == 12) //sdt other (pid 0x11)
261        {
262                sctflt.filter.filter[0] = 0x46;
263                sctflt.filter.mask[0] = 0xff;
264                sctflt.filter.filter[1] = 0x00;
265                sctflt.filter.mask[1] = 0x00;
266                sctflt.filter.filter[2] = 0x00;
267                sctflt.filter.mask[2] = 0x00;
268                sctflt.filter.filter[3] = 0x00;
269                sctflt.filter.mask[3] = 0x00;
270                sctflt.filter.filter[4] = secnr;
271                sctflt.filter.mask[4] = 0xff;
272                sctflt.timeout = 0;
273                sctflt.pid = pid;
274                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
275        }
276        if(flag == 13) //rst filter (pid 0x13)
277        {
278                sctflt.filter.filter[0] = 0x13;
279                sctflt.filter.mask[0] = 0xff;
280                sctflt.timeout = 0;
281                sctflt.pid = pid;
282                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
283        }
284        if(flag == 14) //ait filter
285        {
286                sctflt.filter.filter[0] = 0x74;
287                sctflt.filter.mask[0] = 0xff;
288                sctflt.timeout = 0;
289                sctflt.pid = pid;
290                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
291        }
292        if(flag == 15) //mhw title
293        {
294                sctflt.filter.filter[0] = 0x90;
295                sctflt.filter.mask[0] = 0xff;
296                sctflt.timeout = 0;
297                sctflt.pid = pid;
298                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
299        }
300        if(flag == 16) //mhw channel
301        {
302                sctflt.filter.filter[0] = 0x91;
303                sctflt.filter.mask[0] = 0xff;
304                sctflt.timeout = 0;
305                sctflt.pid = pid;
306                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
307        }
308        if(flag == 17) //mhw summary
309        {
310                sctflt.filter.filter[0] = 0x90;
311                sctflt.filter.mask[0] = 0xff;
312                sctflt.timeout = 0;
313                sctflt.pid = pid;
314                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
315        }
316        if(flag == 18) //mhw2 title
317        {
318                sctflt.filter.filter[0] = 0xe6;
319                sctflt.filter.mask[0] = 0xff;
320                sctflt.timeout = 0;
321                sctflt.pid = pid;
322                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
323        }
324        if(flag == 19) //mhw2 channel
325        {
326                sctflt.filter.filter[0] = 0xc8;
327                sctflt.filter.mask[0] = 0xff;
328                sctflt.timeout = 0;
329                sctflt.pid = pid;
330                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
331        }
332        if(flag == 20) //mhw2 summary
333        {
334                sctflt.filter.filter[0] = 0x96;
335                sctflt.filter.mask[0] = 0xff;
336                sctflt.timeout = 0;
337                sctflt.pid = pid;
338                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
339        }
340        if(flag == 21) //opentv channel
341        {
342                sctflt.filter.filter[0] = 0x4a;
343                sctflt.filter.mask[0] = 0xff;
344                sctflt.timeout = 0;
345                sctflt.pid = pid;
346                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
347        }
348        if(flag == 22) //opentv title
349        {
350                sctflt.filter.filter[0] = 0xa0;
351                sctflt.filter.mask[0] = 0xfc;
352                sctflt.timeout = 0;
353                sctflt.pid = pid;
354                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
355        }
356        if(flag == 23) //opentv summary
357        {
358                sctflt.filter.filter[0] = 0xa8;
359                sctflt.filter.mask[0] = 0xfc;
360                sctflt.timeout = 0;
361                sctflt.pid = pid;
362                sctflt.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;
363        }
364
365        debug(200, "DMX_SET_FILTER pid=%d, flag=%d", pid, flag);
366        if(ioctl(node->fd, DMX_SET_FILTER, &sctflt) < 0)
367        {
368                perr("DMX_SET_FILTER");
369                return 1;
370        }
371
372        return 0;
373}
374
375int dmxaddpid(struct dvbdev* node, int pid)
376{
377        if(node == NULL)
378        {
379                err("NULL detect");
380                return 1;
381        }
382
383        debug(200, "DMX_ADD_PID=%d", pid);
384        while(1)
385        {
386#if DVB_API_VERSION > 3
387                __u16 p = pid;
388                if(ioctl(node->fd, DMX_ADD_PID, &p) < 0)
389#else
390                if(ioctl(node->fd, DMX_ADD_PID, pid) < 0)
391#endif
392                {
393                        perr("DMX_ADD_PID");
394                        if(errno == EAGAIN || errno == EINTR)
395                                continue;
396                        return 1;
397                }
398                break;
399        }
400
401        return 0;
402}
403
404int dmxremovepid(struct dvbdev* node, int pid)
405{
406        if(node == NULL)
407        {
408                err("NULL detect");
409                return 1;
410        }
411
412        debug(200, "DMX_REMOVE_PID=%d", pid);
413        while(1)
414        {
415#if DVB_API_VERSION > 3
416                __u16 p = pid;
417                if(ioctl(node->fd, DMX_REMOVE_PID, &p) < 0)
418#else
419                if(ioctl(node->fd, DMX_REMOVE_PID, pid) < 0)
420#endif
421                {
422                        perr("DMX_REMOVE_PID");
423                        if(errno == EAGAIN || errno == EINTR)
424                                continue;
425                        return 1;
426                }
427                break;
428        }
429
430        return 0;
431}
432
433int dmxgetstc(struct dvbdev* node, int64_t* stc)
434{
435        struct dmx_stc dmxstc;
436
437        if(node == NULL)
438        {
439                err("NULL detect");
440                return 1;
441        }
442
443        memset(&dmxstc, 0, sizeof(struct dmx_stc));
444        dmxstc.num = 0;
445        dmxstc.base = 1;
446
447        debug(200, "DMX_GET_STC");
448        if(ioctl(node->fd, DMX_GET_STC, &dmxstc) < 0)
449        {
450                perr("DMX_GET_STC");
451                return 1;
452        }
453        else
454                *stc = (int64_t)dmxstc.stc;
455
456        return 0;
457}
458
459int dmxsetsource(struct dvbdev* node, int source)
460{
461        if(node == NULL)
462        {
463                err("NULL detect");
464                return 1;
465        }
466
467#ifdef MIPSEL
468        //Workaround da ansonsten DVR4 nicht funktioniert (Treiberproblem)
469       
470        if(source > DMX_SOURCE_DVR0 && status.setdvr0 == 0)
471        {
472                int sourcehelp = DMX_SOURCE_DVR0;
473                ioctl(node->fd, DMX_SET_SOURCE, &sourcehelp);
474                status.setdvr0 = 1;
475        }
476#endif
477//mipsel feinfo work
478//#ifdef SH4
479        debug(200, "DMX_SET_SOURCE=%d", source);
480        if(ioctl(node->fd, DMX_SET_SOURCE, &source) < 0)
481        {
482                perr("DMX_SET_SOURCE");
483        }
484//#endif
485        return 0;
486}
487
488int dmxsetpesfilterfd(int fd, int pid, int input, int output, int pestype, int nostart)
489{
490        struct dmx_pes_filter_params pesflt;
491        memset(&pesflt, 0, sizeof(pesflt));
492
493        if(input == -1)
494        {
495                if(status.playing == 1)
496                        pesflt.input = DMX_IN_DVR;
497                else
498                        pesflt.input = DMX_IN_FRONTEND;
499        }
500        else
501                pesflt.input = input;
502
503        pesflt.output = output;
504        pesflt.pid = pid;
505        if(nostart == 0)
506                pesflt.flags = DMX_IMMEDIATE_START;
507        pesflt.pes_type = pestype;
508
509        debug(200, "DMX_SET_PES_FILTER pid=%d, pestype=%d, input=%d, output=%d", pid, pestype, pesflt.input, output);
510        if(ioctl(fd, DMX_SET_PES_FILTER, &pesflt) < 0)
511        {
512                perr("DMX_SET_PES_FILTER");
513                return 1;
514        }
515
516        return 0;
517}
518
519int dmxsetpesfilter(struct dvbdev* node, int pid, int input, int output, int pestype, int nostart)
520{
521        if(node == NULL)
522        {
523                err("NULL detect");
524                return 1;
525        }
526        return dmxsetpesfilterfd(node->fd, pid, input, output, pestype, nostart);
527}
528
529int dmxgetdev()
530{
531        int i, y, z, fd = -1, count = 0;
532        char *buf = NULL, *dmxdev = NULL;
533
534        dmxdev = getconfig("dmxdev", NULL);
535        if(dmxdev == NULL)
536        {
537                err("NULL detect");
538                return count;
539        }
540
541        buf = malloc(MINMALLOC);
542        if(buf == NULL)
543        {
544                err("no memory");
545                return count;
546        }
547
548        for(i = 0; i < MAXDVBADAPTER; i++)
549        {
550                for(y = 0; y < MAXDEMUXDEV; y++)
551                {
552                        sprintf(buf, dmxdev, i, y);
553                        fd = dmxopendirect(buf);
554                        if(fd >= 0)
555                        {
556                                count++;
557                                for(z = 0; z < MAXDEMUXDEVOPEN; z++)
558                                        adddvbdev(buf, i, y, -1, DEMUXDEV, NULL, NULL, NULL, 0);
559                                //without this, on atevio7500, if the second tuner is the maintuner
560                                //no picture (i don't know why)
561                                dmxsetpesfilterfd(fd, 0, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0);
562                                dmxclose(NULL, fd);
563                        }
564                }
565        }
566
567        free(buf);
568        return count;
569}
570
571#endif
Note: See TracBrowser for help on using the repository browser.