source: titan/titan/service.h @ 44523

Last change on this file since 44523 was 44523, checked in by gost, 3 years ago

test
File size: 28.8 KB
Line 
1#ifndef SERVICE_H
2#define SERVICE_H
3
4void debugservice()
5{
6        struct service* node = service;
7        int count = 0;
8
9        while(node != NULL)
10        {
11                printf("Service %d\n", count);
12                count++;
13
14                if(node->channel != NULL) printf("%s (%llu)\n", node->channel->name, node->channel->transponderid);
15                if(node->transponder != NULL) printf("TransponderID %llu\n", node->transponder->id);
16                if(node->fedev != NULL) printf("%s (%d)\n", node->fedev->dev, node->fedev->fd);
17                if(node->dmxaudiodev != NULL) printf("%s (%d)\n", node->dmxaudiodev->dev, node->dmxaudiodev->fd);
18                if(node->dmxvideodev != NULL) printf("%s (%d)\n", node->dmxvideodev->dev, node->dmxvideodev->fd);
19                if(node->dmxpcrdev != NULL) printf("%s (%d)\n", node->dmxpcrdev->dev, node->dmxpcrdev->fd);
20                if(node->audiodev != NULL) printf("%s (%d)\n", node->audiodev->dev, node->audiodev->fd);
21                if(node->videodev != NULL) printf("%s (%d)\n", node->videodev->dev, node->videodev->fd);
22                node = node->next;
23        }
24}
25
26void serviceresetchannelinfo(struct channel* chnode)
27{
28        if(chnode == NULL) return;
29
30        freeaudiotrack(chnode);
31        freesubtitle(chnode);
32        freepmt(chnode);
33        freecadesc(chnode);
34        freeesinfo(chnode);
35        chnode->txtpid = 0;
36        chnode->pmtpid = 0;
37        chnode->crypt = 0;
38}
39
40void akttolast()
41{
42        if(status.aktservice->fedev != NULL && status.aktservice->fedev->type == FRONTENDDEVDUMMY) return;
43        status.lastservice->fedev = status.aktservice->fedev;
44        status.lastservice->dmxaudiodev = status.aktservice->dmxaudiodev;
45        status.lastservice->dmxvideodev = status.aktservice->dmxvideodev;
46        status.lastservice->dmxpcrdev = status.aktservice->dmxpcrdev;
47        status.lastservice->dmxsubtitledev = status.aktservice->dmxsubtitledev;
48        status.lastservice->audiodev = status.aktservice->audiodev;
49        status.lastservice->videodev = status.aktservice->videodev;
50        status.lastservice->transponder = status.aktservice->transponder;
51        status.lastservice->channel = status.aktservice->channel;
52        free(status.lastservice->channellist);
53        status.lastservice->channellist = ostrcat(status.aktservice->channellist, NULL, 0, 0);
54}
55
56//flag 0: channel
57//flag 1: playback
58//flag 2: timeshift
59//flag 3: same as 0 but don't check chnode
60//flag 4: same as 0 but new tuning
61//flag 5: same as 3 but new tuning
62//flag 6: same as 5 but second zap
63int servicestartreal(struct channel* chnode, char* channellist, char* pin, int flag)
64{
65        struct transponder* tpnode = NULL;
66        struct dvbdev *fenode = NULL;
67        struct dvbdev *dmxaudionode = NULL;
68        struct dvbdev *dmxvideonode = NULL;
69        struct dvbdev *dmxpcrnode = NULL;
70        struct dvbdev *audionode = NULL;
71        struct dvbdev *videonode = NULL;
72        int ret = 0, festatus = 1, tmpmute = 0, i = 0;
73        unsigned char *patbuf = NULL;
74        int checkpmt = 0, pincheck = 0, stopflag = 0, ageprotect = 0, tune = 0, secondzap = 0;
75        struct epg* epgnode = NULL;
76
77        m_lock(&status.servicemutex, 2);
78
79        status.secondzap = 0;
80
81        if(flag == 4 || flag == 5 || flag == 6) tune = 1;
82        if(flag == 6) secondzap = 1;
83        if(flag == 4) flag = 0;
84
85        //wakeup hdd work
86        if(flag == 1 || flag == 2) wakeup_record_device();
87       
88        if(flag == 0 && status.aktservice->type == CHANNEL && status.aktservice->channel != NULL && chnode == status.aktservice->channel)
89        {
90                m_unlock(&status.servicemutex, 2);
91                return 20;
92        }
93        if(flag == 3 || flag == 5 || flag == 6) flag = 0;
94
95        if(chnode == NULL)
96        {
97                m_unlock(&status.servicemutex, 2);
98                return 21;
99        }
100        debug(200, "servicestartreal... started");
101        //stop running autoresolution
102        if(status.restimer != NULL)
103                status.restimer->aktion = STOP;
104
105        if(secondzap == 0)
106        {
107                ageprotect = getconfigint("ageprotect", NULL);
108                if(ageprotect > 0) epgnode = getepgakt(chnode);
109                if(chnode->protect > 0 || (epgnode != NULL && epgnode->parentalrating >= ageprotect))
110                {
111                        pincheck = screenpincheck(1, pin);
112                        if(pincheck == 1)
113                        {
114                                m_unlock(&status.servicemutex, 2);
115                                return 22;
116                        }
117                }
118        }
119
120        //got transponder
121        if(flag == 0)
122        {
123                if(chnode->transponder == NULL)
124                        tpnode = gettransponder(chnode->transponderid);
125                else
126                        tpnode = chnode->transponder;
127        }
128
129        if(flag == 1 || flag == 2)
130                stopflag = 2;
131        else if(secondzap == 1)
132                stopflag = 3;
133        if(getconfigint("nozapclear", NULL) == 1)
134                ret = servicestop(status.aktservice, 0, stopflag);
135        else
136                ret = servicestop(status.aktservice, 1, stopflag);
137
138        //can't stop service (timeshift ??)
139        if(ret == 1)
140        {
141                m_unlock(&status.servicemutex, 2);
142                return 22;
143        }
144       
145        //reset channel info
146        if(flag == 0) serviceresetchannelinfo(chnode);
147
148        status.aktservice->transponder = tpnode;
149        status.aktservice->channel = chnode;
150        status.aktservice->type = CHANNEL;
151        if(status.epgthread != NULL) status.epgthread->aktion = PAUSE;
152
153        if(flag == 0 && status.aktservice->type == CHANNEL)
154                changechannellist(chnode, channellist);
155
156        //got frontend dev
157        if(flag == 0)
158        {
159                fenode = fegetfree(tpnode, 0, NULL, chnode);
160                if(fenode == NULL)
161                {
162                        m_unlock(&status.servicemutex, 2);
163                        return 1;
164                }
165               
166#ifdef DREAMBOX
167                if(status.aktservice->fedev != fenode)
168                {
169                        int fastzap = getconfigint("fastzap", NULL);
170                        if(fastzap == 1)
171                        {
172                                audioclose(status.aktservice->audiodev, -1);
173                                status.aktservice->audiodev = NULL;
174                                dmxstop(status.aktservice->dmxaudiodev);
175                                dmxclose(status.aktservice->dmxaudiodev, -1);
176                                status.aktservice->dmxaudiodev = NULL;
177                        }
178                        if(fastzap == 1 || fastzap == 2)
179                        {
180                                videoclose(status.aktservice->videodev, -1);
181                                status.aktservice->videodev = NULL;
182                                dmxstop(status.aktservice->dmxvideodev);
183                                dmxclose(status.aktservice->dmxvideodev, -1);
184                                status.aktservice->dmxvideodev = NULL;
185                                dmxstop(status.aktservice->dmxpcrdev);
186                                dmxclose(status.aktservice->dmxpcrdev, -1);
187                                status.aktservice->dmxpcrdev = NULL;
188                                dmxstop(status.aktservice->dmxsubtitledev);
189                                dmxclose(status.aktservice->dmxsubtitledev, -1);
190                                status.aktservice->dmxsubtitledev = NULL;
191                        }
192                }
193#endif
194                               
195                status.aktservice->fedev = fenode;
196
197                //frontend tune
198                if(fenode->felasttransponder != tpnode || tune == 1)
199                {
200                        if(fenode->feinfo->type == FE_QPSK)
201                        {
202                                feset(fenode, tpnode);
203                                fetunedvbs(fenode, tpnode);
204                        }
205                        else if(fenode->feinfo->type == FE_QAM)
206                                fetunedvbc(fenode, tpnode);
207                        else if(fenode->feinfo->type == FE_OFDM)
208                                fetunedvbt(fenode, tpnode);
209                        else
210                        {
211                                m_unlock(&status.servicemutex, 2);
212                                return 3;
213                        }
214                }
215        }
216        else if(flag == 1 || flag == 2)
217        {
218                fenode = fegetdummy();
219                status.aktservice->fedev = fenode;
220        }
221
222        if(fenode == NULL)
223        {
224                m_unlock(&status.servicemutex, 2);
225                return 1;
226        }
227
228        //check pmt if not all infos in channellist
229        if(chnode->audiopid == -1 || chnode->videopid == -1 || chnode->pcrpid == -1 || chnode->audiocodec == -1 || chnode->videocodec == -1 || (getconfigint("av_ac3default", NULL) == YES && chnode->audiocodec != AC3))
230        {
231                //wait for tuner lock
232                if(flag == 0)
233                {
234                        if(fenode->felasttransponder != tpnode)
235                                festatus = fewait(fenode);
236                        else
237                                festatus = fegetunlock(fenode);
238
239                        if(debug_level == 200) 
240                        {
241                                fereadstatus(fenode);
242                                fegetfrontend(fenode);
243                        }
244                        if(festatus != 0)
245                        {
246                                m_unlock(&status.servicemutex, 2);
247                                return 2;
248                        }
249                }
250
251                checkpmt = 1;
252                if(flag != 1 || (flag == 1 && chnode->pmtpid == 0))
253                {
254                        patbuf = dvbgetpat(fenode, -1);
255                        if(patbuf == NULL) status.secondzap = 1;
256                }
257                debug(200, "1-secondzap=%i", status.secondzap);
258                free(status.aktservice->pmtbuf);
259                status.aktservice->pmtbuf = NULL;
260                status.aktservice->pmtlen = 0;
261                if(patbuf != NULL)
262                        status.aktservice->pmtbuf = dvbgetpmt(fenode, patbuf, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 0);
263                else if(chnode->pmtpid > 0)
264                        status.aktservice->pmtbuf = dvbgetpmt(fenode, NULL, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 1);
265
266                if(status.aktservice->pmtbuf == NULL) status.secondzap = 2;
267                debug(200, "2-secondzap=%i", status.secondzap);
268                dvbgetinfo(status.aktservice->pmtbuf, chnode);
269
270                if(flag == 0)
271                {
272                        if(status.pmtmode == 1)
273                        {
274                                if(recordcheckcrypt(fenode, CHANNEL) == 0)
275                                        dvbwritepmt(status.aktservice, status.aktservice->pmtbuf);
276                                else
277                                        debug(200, "don't write pmt.tmp, another crypt channel use this frontend");
278                        }
279                        else
280                                sendcapmt(status.aktservice, 0, 0);
281                }
282                free(patbuf);
283        }
284
285        if(flag != 0) checkpmt = 1;
286
287        //set mute for scat problem
288#ifdef MIPSEL   
289        if(status.mute != 0)
290        {
291                setmute(0);
292                tmpmute = 1;
293        }
294#else
295        if(status.mute == 0)
296        {
297                tmpmute = 1;
298                //setmute(1);
299                audiosetmute(status.aktservice->audiodev, 1);
300        }
301#endif         
302        audiostop(status.aktservice->audiodev);
303        if(checkbox("DM900") == 1 || checkbox("DM920") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1 || checkchipset("HI3798MV200") == 1)
304                dmxstop(status.aktservice->dmxaudiodev);
305
306// gost test multibox
307        if(checkchipset("HI3798MV200") == 1  || vubox1 == 1)
308        {
309                videostop(status.aktservice->videodev, 1);
310                dmxstop(status.aktservice->dmxvideodev);
311        }
312
313        //demux pcr start
314        if(flag == 0 && chnode->pcrpid > 0)
315        {
316                if(status.aktservice->dmxpcrdev != NULL && status.aktservice->dmxpcrdev->fd >= 0 && status.aktservice->dmxpcrdev->adapter == fenode->adapter && status.aktservice->dmxpcrdev->devnr == fenode->devnr)
317                        dmxpcrnode = status.aktservice->dmxpcrdev;
318                else
319                {
320                        dmxclose(status.aktservice->dmxpcrdev, -1);
321                        dmxpcrnode = dmxopen(fenode, 2);
322                }
323                if(dmxpcrnode != NULL)
324                {
325                        if(dmxsetsource(dmxpcrnode, fenode->fedmxsource) != 0)
326                        {
327                                dmxclose(dmxpcrnode, -1);
328                                dmxpcrnode = NULL;
329                        }
330                        if(dmxsetpesfilter(dmxpcrnode, chnode->pcrpid, -1, DMX_OUT_DECODER, DMX_PES_PCR, 0) != 0)
331                        {
332                                dmxclose(dmxpcrnode, -1);
333                                dmxpcrnode = NULL;
334                        }
335                }
336                else
337                        err("demux pcr dev not ok");
338        }
339        else
340        {
341                err("dmx pcrpid not valid (%d)", chnode->pcrpid);
342                dmxclose(status.aktservice->dmxpcrdev, -1);
343        }
344
345        status.aktservice->dmxpcrdev = dmxpcrnode;
346
347        //demux audio start
348        if(chnode->audiopid > 0)
349        {
350                if(status.aktservice->dmxaudiodev != NULL && status.aktservice->dmxaudiodev->fd >= 0 && status.aktservice->dmxaudiodev->adapter == fenode->adapter && status.aktservice->dmxaudiodev->devnr == fenode->devnr)
351                        dmxaudionode = status.aktservice->dmxaudiodev;
352                else
353                {
354                        dmxclose(status.aktservice->dmxaudiodev, -1);
355                        dmxaudionode = dmxopen(fenode, 2);
356                        if(dmxsetbuffersize(dmxaudionode, getconfigint("dmxaudiobuffersize", NULL)) != 0)
357                        {
358                                dmxclose(dmxaudionode, -1);
359                                dmxaudionode = NULL;
360                        }
361                }
362                if(dmxaudionode != NULL)
363                {
364                        if(dmxsetsource(dmxaudionode, fenode->fedmxsource) != 0)
365                        {
366                                dmxclose(dmxaudionode, -1);
367                                dmxaudionode = NULL;
368                        }
369                        if(dmxsetpesfilter(dmxaudionode, chnode->audiopid, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0) != 0)
370                        {
371                                dmxclose(dmxaudionode, -1);
372                                dmxaudionode = NULL;
373                        }
374                }
375                else
376                        err("demux audio dev not ok");
377        }
378        else
379        {
380                err("dmx audiopid not valid (%d)", chnode->audiopid);
381                dmxclose(status.aktservice->dmxaudiodev, -1);
382        }
383
384        status.aktservice->dmxaudiodev = dmxaudionode;
385
386        //demux video start
387        if(chnode->videopid > 0)
388        {
389                if(status.aktservice->dmxvideodev != NULL && status.aktservice->dmxvideodev->fd >= 0 && status.aktservice->dmxvideodev->adapter == fenode->adapter && status.aktservice->dmxvideodev->devnr == fenode->devnr)
390                        dmxvideonode = status.aktservice->dmxvideodev;
391                else
392                {
393                        dmxclose(status.aktservice->dmxvideodev, -1);
394                        dmxvideonode = dmxopen(fenode, 2);
395                        if(dmxsetbuffersize(dmxvideonode, getconfigint("dmxvideobuffersize", NULL)) != 0)
396                        {
397                                dmxclose(dmxvideonode, -1);
398                                dmxvideonode = NULL;
399                        }
400                        status.aktservice->dmxvideodev = dmxvideonode;
401                }
402                if(dmxvideonode != NULL)
403                {
404                        if(dmxsetsource(dmxvideonode, fenode->fedmxsource) != 0)
405                        {
406                                dmxclose(dmxvideonode, -1);
407                                dmxvideonode = NULL;
408                        }
409                        if(dmxsetpesfilter(dmxvideonode, chnode->videopid, -1, DMX_OUT_DECODER, DMX_PES_VIDEO, 0) != 0)
410                        {
411                                dmxclose(dmxvideonode, -1);
412                                dmxvideonode = NULL;
413                        }
414                }
415                else
416                        err("demux video dev not ok");
417        }
418        else
419        {
420                err("dmx videopid not valid (%d)", chnode->videopid);
421                dmxclose(status.aktservice->dmxvideodev, -1);
422        }
423
424        status.aktservice->dmxvideodev = dmxvideonode;
425       
426        //workaround for some audio channel not playing (for test)
427        usleep(100000);
428
429        //audio start
430        if(dmxaudionode != NULL)
431        {
432                if(status.aktservice->audiodev != NULL && status.aktservice->audiodev->fd >= 0 && status.aktservice->audiodev->adapter == fenode->adapter)
433                        audionode = status.aktservice->audiodev;
434                else
435                {
436                        audioclose(status.aktservice->audiodev, -1);
437                        audionode = audioopen(fenode->adapter);
438                        status.aktservice->audiodev = audionode;
439                }
440                if(audionode != NULL)
441                {
442                        audioselectsource(audionode, AUDIO_SOURCE_DEMUX);
443                        audiosetbypassmode(audionode, chnode->audiocodec);
444                        if(checkbox("VUSOLO2") == 1 || checkchipset("HI3798MV200") == 1 || vubox1 == 1) //fixt only audio no video.. blackscreen after zap
445                                audiopause(audionode);
446                        if(status.mute != 1)
447                        {
448                                // needs for ts playback
449                                if(checkchipset("3798MV200") == 1 || checkbox("DM900") == 1 || checkbox("DM920") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1)
450                                        dmxstart(status.aktservice->dmxaudiodev);
451                                audioplay(audionode);
452                        }
453                }
454                else
455                        err("can't get free audio dev");
456        }
457       
458        //video start
459        if(dmxvideonode != NULL)
460        {
461                if(status.aktservice->videodev != NULL && status.aktservice->videodev->fd >= 0 && status.aktservice->videodev->adapter == fenode->adapter)
462                        videonode = status.aktservice->videodev;
463                else
464                {
465                        videoclose(status.aktservice->videodev, -1);
466                        videonode = videoopen(fenode->adapter, 0);
467                        status.aktservice->videodev = videonode;
468                }
469                if(videonode != NULL)
470                {
471                        videocontinue(videonode);
472                        videoselectsource(videonode, VIDEO_SOURCE_DEMUX);
473                        setencoding(chnode, videonode);
474
475                        // needs for ts playpack
476                        if(checkchipset("3798MV200") == 1)
477                                dmxstart(status.aktservice->dmxvideodev);
478
479                        if(checkbox("VUSOLO2") == 1 || vubox1 == 1 ) //fixt only audio no video.. blackscreen after zap
480                                videofreeze(videonode);
481
482                        if(videoplay(videonode)!= 0) {
483                                usleep(500000);
484                                videoplay(videonode);
485                        }
486                }
487                else
488                        err("can't get free video dev");
489                if(checkchipset("HI3798MV200") == 1 || vubox1 == 1)
490                {
491                        videoslowmotion(videonode, 0);
492                        videofastforward(videonode, 0);
493                        videocontinue(videonode);
494                }
495        }
496#ifdef MIPSEL
497        if(checkchipset("HI3798MV200") == 1 || vubox1 == 1)
498        {
499                audiocontinue(audionode);
500        }       
501        if(tmpmute == 1)
502        {
503                tmpmute = 0;
504                setmute(1);
505        }
506#else   
507        //unset mute if set here
508        if(tmpmute == 1)
509        {
510                tmpmute = 0;
511                audiosetmute(status.aktservice->audiodev, 0);
512                //setmute(0);
513        }
514        if(status.mute != 1)
515        {
516                if(checkbox("DM900") == 1 || checkbox("DM920") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1)
517                        dmxstart(status.aktservice->dmxaudiodev);
518                audioplay(status.aktservice->audiodev);
519        }
520#endif
521       
522        //check pmt if not done
523        if(checkpmt == 0)
524        {
525                //wait for tuner lock
526                if(flag == 0)
527                {
528                        if(fenode->felasttransponder != tpnode)
529                                festatus = fewait(fenode);
530                        else
531                        {
532                                festatus = fegetunlock(fenode);
533                                if(festatus != 0)
534                                {
535                                        debug(200, "fegetunlock rc:%d ... now fewait", festatus);       
536                                        festatus = fewait(fenode);
537                                }
538                        }
539
540                        if(debug_level == 200)
541                        {
542                                fereadstatus(fenode);
543                                fegetfrontend(fenode);
544                        }
545                        if(festatus != 0)
546                        {
547                                m_unlock(&status.servicemutex, 2);
548                                return 2;
549                        }
550                }
551
552                checkpmt = 1;
553                patbuf = dvbgetpat(fenode, -1);
554                if(patbuf == NULL) status.secondzap = 3;
555                debug(200, "3-secondzap=%i", status.secondzap);
556                free(status.aktservice->pmtbuf);
557                status.aktservice->pmtbuf = NULL;
558                status.aktservice->pmtlen = 0;
559                if(patbuf != NULL)
560                        status.aktservice->pmtbuf = dvbgetpmt(fenode, patbuf, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 0);
561                else if(chnode->pmtpid > 0)
562                        status.aktservice->pmtbuf = dvbgetpmt(fenode, NULL, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 1);
563
564                if(status.aktservice->pmtbuf == NULL) status.secondzap = 4;
565                debug(200, "4-secondzap=%i", status.secondzap);
566                if(dvbgetinfo(status.aktservice->pmtbuf, chnode) == 1)
567                {
568                        //audio or video pid or codec changed
569                        free(status.aktservice->pmtbuf);
570                        status.aktservice->pmtbuf = NULL;
571                        status.aktservice->pmtlen = -1;
572                }
573
574                if(flag == 0)
575                {
576                        if(status.pmtmode == 1)
577                        {
578                                if(recordcheckcrypt(fenode, CHANNEL) == 0)
579                                        dvbwritepmt(status.aktservice, status.aktservice->pmtbuf);
580                                else
581                                        debug(200, "don't write pmt.tmp, another crypt channel use this frontend");
582                        }
583                        else
584                                sendcapmt(status.aktservice, 0, 0);
585                }
586                free(patbuf);
587        }
588
589        //get ait and parse it for hbbtv url
590        if(flag == 0 && chnode->aitpid > 0)
591        {
592                unsigned char* aitbuf = NULL;
593                aitbuf = dvbgetait(fenode, chnode->aitpid, 0, -1);
594                if(aitbuf != NULL)
595                {
596                        free(chnode->hbbtvurl); chnode->hbbtvurl = NULL;
597                        chnode->hbbtvurl = dvbgethbbtvurl(aitbuf);
598                }
599
600                debug(200, "hbbtvurl=%s", chnode->hbbtvurl);
601                free(aitbuf); aitbuf = NULL;
602        }
603
604        if(flag == 0)
605        {
606                //add channel to history
607                if(status.aktservice->type == CHANNEL)
608                {
609                        addchannelhistory(chnode, status.aktservice->channellist);
610                        if(status.servicetype == 0) //only for tv
611                                createmostzap(chnode->serviceid, chnode->transponderid);
612                }
613                festatus = fewait(fenode);
614                if(festatus != 0)
615                {
616                        m_unlock(&status.servicemutex, 2);
617                        err("festatus=%i", festatus );
618                        return 2;
619                }
620        }
621
622        //wait for epg thread stops
623        if(flag == 0 && status.epgthread != NULL)
624        {
625                i = 0;
626                while(status.epgthread->status != INPAUSE)
627                {
628                        usleep(10000);
629                        i++; if(i > 300) break;
630                }
631                status.epgthread->aktion = START;
632        }
633
634        status.videosizevalid = time(NULL);
635        m_unlock(&status.servicemutex, 2);
636       
637        //auto change channel name
638        if(flag == 0 && status.autochangechannelname == 1)
639                addtimer(&autochangechannelname, START, 1000, 1, NULL, NULL, NULL);
640       
641        //autoresolution
642        if(flag == 0 && ostrcmp(getconfig("av_videomode_autores", NULL), "auto") == 0)
643        {
644                int sec = 7;
645                char* av_videomode_autores_ts = getconfig("av_videomode_autores_ts", NULL);
646                if(av_videomode_autores_ts != NULL)
647                        sec = atoi(av_videomode_autores_ts);
648                if(status.restimer == NULL)
649                        status.restimer = addtimer(&setaktres, START, 1000, 1, (void*)sec, NULL, NULL);
650                else
651                {
652                        status.restimer->aktion = STOP;
653                        status.restimer = addtimer(&setaktres, START, 1000, 1, (void*)sec, NULL, NULL);
654                }                       
655        }
656       
657        if(flag == 0 && status.autosubtitle == 1) subtitlestartlast(); //start subtitle
658        if(flag == 0 && status.timeshifttype == 1)
659        {
660                i = 0;
661                while(status.timeshift > 0)
662                {
663                        usleep(100000);
664                        i++; if(i > 20) break;
665                }
666                timeshiftpause(); //start permanent timeshift record
667        }
668       
669        debug(200, "servicestartreal... ended with 0");
670        return 0;
671}
672
673//second zap on failure
674int servicestart(struct channel* chnode, char* channellist, char* pin, int flag)
675{
676        int ret = 0;
677       
678        ret = servicestartreal(chnode, channellist, pin, flag);
679        debug(200, "servicestart... started");
680        if(status.secondzap != 0 && ret == 0 && (flag == 0 || flag > 2))
681        {
682                debug(200, "first zap not ok, make second zap (%d)", status.secondzap);
683                ret = servicestartreal(chnode, channellist, pin, 6);
684        }
685        debug(200, "servicestart... ended");
686        return ret;
687}
688
689//flag 0: lock
690//flag 1: no lock
691struct service* getservicebyrecname(char* file, int type, int flag)
692{
693        if(file == NULL) return NULL;
694
695        if(flag == 0) m_lock(&status.servicemutex, 2);
696        struct service* snode = service;
697
698        while(snode != NULL)
699        {
700                if(ostrcmp(snode->recname, file) == 0 && (type == 0 || (type == 1 && (snode->type == RECORDDIRECT || snode->type == RECORDTIMER))))
701                {
702                        if(flag == 0) m_unlock(&status.servicemutex, 2);
703                        return snode;
704                }
705                snode = snode->next;
706        }
707        if(flag == 0) m_unlock(&status.servicemutex, 2);
708        return NULL;
709}
710
711struct service* getservicebychannel(struct channel* chnode)
712{
713        m_lock(&status.servicemutex, 2);
714        struct service* snode = service;
715
716        while(snode != NULL)
717        {
718                if(snode->channel == chnode)
719                {
720                        m_unlock(&status.servicemutex, 2);
721                        return snode;
722                }
723                snode = snode->next;
724
725        }
726        m_unlock(&status.servicemutex, 2);
727        return NULL;
728}
729
730//flag 0: lock
731//flag 1: no lock
732struct service* getservicebyrectimestamp(char* timestamp, int flag)
733{
734        if(timestamp == 0) return NULL;
735
736        if(flag == 0) m_lock(&status.servicemutex, 2);
737        struct service* snode = service;
738
739        while(snode != NULL)
740        {
741                if(ostrcmp(snode->rectimestamp, timestamp) == 0)
742                {
743                        if(flag == 0) m_unlock(&status.servicemutex, 2);
744                        return snode;
745                }
746                snode = snode->next;
747        }
748        if(flag == 0) m_unlock(&status.servicemutex, 2);
749        return NULL;
750}
751
752struct service* getservicebyservice(struct service* node, int flag)
753{
754        if(flag == 0) m_lock(&status.servicemutex, 2);
755        struct service* snode = service;
756
757        while(snode != NULL)
758        {
759                if(snode != status.lastservice && snode != node && snode->channel == node->channel)
760                {
761                        if(flag == 0) m_unlock(&status.servicemutex, 2);
762                        return snode;
763                }
764                snode = snode->next;
765        }
766        if(flag == 0) m_unlock(&status.servicemutex, 2);
767        return NULL;
768}
769
770//flag 0: with mutex
771//flag 1: without mutex
772struct service* getservice(int type, int flag)
773{
774        if(flag == 0) m_lock(&status.servicemutex, 2);
775        struct service* snode = service;
776
777        while(snode != NULL)
778        {
779                if(snode->type == type)
780                {
781                        if(flag == 0) m_unlock(&status.servicemutex, 2);
782                        return snode;
783                }
784                snode = snode->next;
785        }
786        if(flag == 0) m_unlock(&status.servicemutex, 2);
787        return NULL;
788}
789
790//flag 0: faststop depends on param faststop
791//flag 1: always normal stop
792//flag 2: from timeshift/player
793//flag 3: same as 0 but no akttolast
794//flag 4: showiframe
795int servicestop(struct service *node, int clear, int flag)
796{
797        int rcret = 0;
798
799        if(node != NULL)
800        {
801                status.tvpic = 0;
802
803                if(status.timeshift == 1 && flag != 2)
804                {
805                        if(status.timeshifttype == 0 && status.asktimeshift == 0)
806                                rcret = textbox(_("Message"), _("Timeshift is running !!!\nStop it and switch ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 400, 10, 0);
807
808                        if(rcret == 2) return 1;
809                        timeshiftstop(1);
810                }
811                if(flag != 2 && node->type != NOTHING && node->type != STILLPIC) caservicedel(node, NULL);
812
813
814                truncate("/tmp/ecm.info", 0);
815                unlink("/tmp/pid.info");
816                unlink("/tmp/caids.info");
817               
818                status.videosizevalid = 0;
819
820                if(status.epgthread != NULL) status.epgthread->aktion = PAUSE;
821                subtitlestop(0);
822
823
824                if(node->type == CHANNEL && flag < 2) akttolast();
825
826                if(flag != 2) node->type = NOTHING;
827                if(flag == 4) node->type = STILLPIC;
828       
829                audiostop(node->audiodev);
830                if(checkbox("DM900") == 1 || checkbox("DM920") == 1 || checkbox("DM520") == 1 || checkbox("DM525") == 1 || checkchipset("HI3798MV200") == 1)
831                        dmxstop(status.aktservice->dmxaudiodev);
832
833                if(checkbox("VUSOLO2") == 1)
834                {
835//                      videofreeze(status.aktservice->videodev);
836//                      dmxstart(status.aktservice->dmxaudiodev);
837//                      audioplay(status.aktservice->audiodev);
838//                      audiopause(status.aktservice->audiodev);
839                        videoclearbuffer(status.aktservice->videodev);
840                        audioclearbuffer(status.aktservice->audiodev);
841//                      videoslowmotion(status.aktservice->videodev, 0);
842//                      videofastforward(status.aktservice->videodev, 0);
843                }
844                else if(vubox1 == 1)
845                {
846                        videoclearbuffer(node->videodev);
847                        audioclearbuffer(node->audiodev);
848                }
849                else
850                {
851
852                        dmxstop(node->dmxaudiodev);
853                        videostop(node->videodev, clear);
854                }
855                int     fastzap = getconfigint("fastzap", NULL);
856
857                if(flag == 3) flag = 0;
858                if(flag == 4 || flag == 1 || (flag == 0 && (fastzap == 0 || fastzap == 2)))
859                {
860                        audioclose(node->audiodev, -1);
861                        node->audiodev = NULL;
862                        dmxstop(node->dmxaudiodev);
863                        dmxclose(node->dmxaudiodev, -1);
864                        node->dmxaudiodev = NULL;
865                }
866               
867                if(flag == 4 || flag == 1 || (flag == 0 && fastzap == 0))
868                {
869                        printf("[titan] service.h -> servicestop close all");
870                        videoclose(node->videodev, -1);
871                        //test iframe in MC
872                        if(checkchipset("HI3798MV200") == 1)
873                        {
874                                dmxstop(status.aktservice->dmxvideodev);
875                                dmxclose(status.aktservice->dmxvideodev, -1);
876                                videostop(status.aktservice->videodev, 0);
877                                videoclose(status.aktservice->videodev, -1);
878                        }
879                        node->videodev = NULL;
880                        dmxstop(node->dmxvideodev);
881                        dmxclose(node->dmxvideodev, -1);
882                        node->dmxvideodev = NULL;
883                        dmxstop(node->dmxpcrdev);
884                        dmxclose(node->dmxpcrdev, -1);
885                        node->dmxpcrdev = NULL;
886                        dmxstop(node->dmxsubtitledev);
887                        dmxclose(node->dmxsubtitledev, -1);
888                        node->dmxsubtitledev = NULL;
889                }
890                return 0;
891        }
892        return 1;
893}
894
895void servicechangeaudio(struct channel* chnode, struct audiotrack* tracknode)
896{
897        if(chnode == NULL || tracknode == NULL)
898        {
899                err("NULL detect");
900                return;
901        }
902
903        if(chnode->audiopid == tracknode->audiopid && chnode->audiocodec == tracknode->audiocodec)
904                return;
905
906        chnode->audiopid = tracknode->audiopid;
907        chnode->audiocodec = tracknode->audiocodec;
908
909        status.writechannel = 1;
910        audiostop(status.aktservice->audiodev);
911        audiosetbypassmode(status.aktservice->audiodev, chnode->audiocodec);
912        //clear videobuffer on playback for syncing video / audio
913        if(status.playing == 1) videoclearbuffer(status.aktservice->videodev);
914        dmxsetpesfilter(status.aktservice->dmxaudiodev, chnode->audiopid, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0);
915        if((checkchipset("HI3798MV200") == 1) && status.aktservice->audiodev != NULL)
916                audiopause(status.aktservice->audiodev);
917
918        //don't start audio play, if we are in timeshift record, but not playing mode
919        if(status.timeshifttype == 0 && status.timeshift == 1 && status.playing == 0) return;
920        if(status.timeshifttype == 1 && status.timeshift == 1 && status.playing == 0 && status.timeshiftpos > 0) return;
921
922        if(status.mute != 1)
923                audioplay(status.aktservice->audiodev);
924}
925
926struct service* addservice(struct service* last)
927{
928        struct service *newnode = NULL, *node = NULL;
929
930        newnode = (struct service*)calloc(1, sizeof(struct service));
931        if(newnode == NULL)
932        {
933                err("no memory");
934                return NULL;
935        }
936
937        newnode->recdstfd = -1;
938        newnode->recsrcfd = -1;
939        newnode->tssize = 188;
940
941        m_lock(&status.servicemutex, 2);
942        node = service;
943        if(node != NULL)
944        {
945                if(last == NULL)
946                {
947                        while(node->next != NULL)
948                                node = node->next;
949                        node->next = newnode;
950                }
951                else
952                        last->next = newnode;
953        }
954        else
955                service = newnode;
956
957        m_unlock(&status.servicemutex, 2);
958        return newnode;
959}
960
961struct service* checkservice(struct service* node)
962{
963        struct service* snode = service;
964
965        while(snode != NULL)
966        {
967                if(snode == node)
968                        return snode;
969                snode = snode->next;
970        }
971        return NULL;
972}
973
974//flag 0: set mutex
975//flag 1: not set mutex
976void delservice(struct service* snode, int flag)
977{
978        m_lock(&status.servicemutex, 2);
979        struct service *node = service, *prev = service;
980        struct rectimer *rectimernode = NULL;
981
982        while(node != NULL)
983        {
984                if(node == snode)
985                {
986                        if(node == service)
987                                service = node->next;
988                        else
989                                prev->next = node->next;
990
991                        dmxclose(node->dmxaudiodev, -1);
992                        dmxclose(node->dmxvideodev, -1);
993                        dmxclose(node->dmxpcrdev, -1);
994                        dmxclose(node->dmxsubtitledev, -1);
995                        audioclose(node->audiodev, -1);
996                        videoclose(node->videodev, -1);
997                        close(node->recdstfd);
998                        close(node->recsrcfd);
999                        caservicedel(node, NULL);
1000
1001                        //check if a rectimer is joined with a service
1002                        if(node->type == RECORDTIMER)
1003                        {
1004                                if(flag == 0)
1005                                        m_lock(&status.rectimermutex, 1);
1006
1007                                rectimernode = getrectimerbyservice(node);
1008                                if(rectimernode != NULL)
1009                                {
1010                                        rectimernode->servicenode = NULL;
1011                                        if(rectimernode->status == 0 || rectimernode->status == 1)
1012                                        {
1013                                                rectimernode->status = 2;
1014                                                status.writerectimer = 1;
1015                                                writerectimer(getconfig("rectimerfile", NULL), 1);
1016                                        }
1017                                }
1018
1019                                if(flag == 0)
1020                                        m_unlock(&status.rectimermutex, 1);
1021                        }
1022
1023                        free(node->channellist);
1024                        node->channellist = NULL;
1025
1026                        free(node->recname);
1027                        node->recname = NULL;
1028
1029                        free(node->rectimestamp);
1030                        node->rectimestamp = NULL;
1031
1032                        free(node->pmtbuf);
1033                        node->pmtbuf = NULL;
1034
1035                        free(node);
1036                        node = NULL;
1037                        break;
1038                }
1039
1040                prev = node;
1041                node = node->next;
1042        }
1043        m_unlock(&status.servicemutex, 2);
1044}
1045
1046void freeservice()
1047{
1048        struct service *node = service, *prev = service;
1049
1050        while(node != NULL)
1051        {
1052                prev = node;
1053                node = node->next;
1054                if(prev != NULL)
1055                        delservice(prev, 0);
1056        }
1057}
1058
1059char* servicecheckret(int ret, int flag)
1060{
1061        char* tmpstr = NULL;
1062
1063        if(ret != 0)
1064        {
1065                switch(ret)
1066                {
1067                        case 1:
1068                                tmpstr = ostrcat(_("Can't find a Tuner.\nAll Tuners in use or no Tuner defined."), NULL, 0, 0);
1069                                break;
1070                        case 2:
1071                                tmpstr = ostrcat(_("Tuning to Channel failed!"), NULL, 0, 0);
1072                                break;
1073                        case 3:
1074                                tmpstr = ostrcat(_("Can't open frontend dev or Frontend Type unknown!"), NULL, 0, 0);
1075                                break;
1076                        case 20:
1077                                break;
1078                        case 21:
1079                                tmpstr = ostrcat(_("Channellist empty or corrupt (channel not found)!"), NULL, 0, 0);
1080                                break;
1081                        case 22:
1082                                break;
1083                }
1084                if(tmpstr != NULL)
1085                        textbox(_("Message"), tmpstr, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
1086        }
1087
1088        if(flag != 1)
1089        {
1090                free(tmpstr);
1091                tmpstr = NULL;
1092        }
1093
1094        return tmpstr;
1095}
1096
1097#ifdef MIPSEL
1098void servicefullHDMIin_start()
1099{
1100        struct dvbdev *videonode = NULL;
1101        struct dvbdev *audionode = NULL;
1102        struct channel *chnode = NULL;
1103       
1104        servicestop(status.aktservice, 1, 1);
1105       
1106        audionode = audioopen(0);
1107        if(audionode != NULL)
1108        {
1109                audioselectsource(audionode, AUDIO_SOURCE_HDMI);
1110                audioplay(audionode);
1111        }
1112        videonode = videoopen(0, 0);
1113        if(videonode != NULL)
1114        {
1115                videoselectsource(videonode, VIDEO_SOURCE_HDMI);
1116                videosetstreamtype(videonode, 0);
1117                videoplay(videonode);
1118        }
1119        status.aktservice->videodev = videonode;
1120        status.aktservice->audiodev = audionode;
1121        status.aktservice->type = HDMIIN;
1122        chnode = getchannel(65535, 0);
1123        if(chnode == NULL)
1124                //chnode = createchannel("HDMIIN", 0, 0, 65535, 99, 0, -1, -1, -1, -1, 0, -1);
1125                chnode = createchannel("HDMIIN", 0, 0, 65535, 0, 0, -1, -1, -1, -1, 0, -1);
1126        status.aktservice->channel = chnode;
1127}
1128#endif
1129
1130#endif
Note: See TracBrowser for help on using the repository browser.