source: titan/titan/dmxdev.h @ 45021

Last change on this file since 45021 was 44770, checked in by gost, 4 years ago

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