source: titan/titan/service.h @ 40930

Last change on this file since 40930 was 40930, checked in by gost, 5 years ago

fix

File size: 27.0 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);
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        //demux pcr start
304        if(flag == 0 && chnode->pcrpid > 0)
305        {
306                if(status.aktservice->dmxpcrdev != NULL && status.aktservice->dmxpcrdev->fd >= 0 && status.aktservice->dmxpcrdev->adapter == fenode->adapter && status.aktservice->dmxpcrdev->devnr == fenode->devnr)
307                        dmxpcrnode = status.aktservice->dmxpcrdev;
308                else
309                {
310                        dmxclose(status.aktservice->dmxpcrdev, -1);
311                        dmxpcrnode = dmxopen(fenode, 2);
312                }
313                if(dmxpcrnode != NULL)
314                {
315                        if(dmxsetsource(dmxpcrnode, fenode->fedmxsource) != 0)
316                        {
317                                dmxclose(dmxpcrnode, -1);
318                                dmxpcrnode = NULL;
319                        }
320                        if(dmxsetpesfilter(dmxpcrnode, chnode->pcrpid, -1, DMX_OUT_DECODER, DMX_PES_PCR, 0) != 0)
321                        {
322                                dmxclose(dmxpcrnode, -1);
323                                dmxpcrnode = NULL;
324                        }
325                }
326                else
327                        err("demux pcr dev not ok");
328        }
329        else
330        {
331                err("dmx pcrpid not valid (%d)", chnode->pcrpid);
332                dmxclose(status.aktservice->dmxpcrdev, -1);
333        }
334
335        status.aktservice->dmxpcrdev = dmxpcrnode;
336
337        //demux audio start
338        if(chnode->audiopid > 0)
339        {
340                if(status.aktservice->dmxaudiodev != NULL && status.aktservice->dmxaudiodev->fd >= 0 && status.aktservice->dmxaudiodev->adapter == fenode->adapter && status.aktservice->dmxaudiodev->devnr == fenode->devnr)
341                        dmxaudionode = status.aktservice->dmxaudiodev;
342                else
343                {
344                        dmxclose(status.aktservice->dmxaudiodev, -1);
345                        dmxaudionode = dmxopen(fenode, 2);
346                        if(dmxsetbuffersize(dmxaudionode, getconfigint("dmxaudiobuffersize", NULL)) != 0)
347                        {
348                                dmxclose(dmxaudionode, -1);
349                                dmxaudionode = NULL;
350                        }
351                }
352                if(dmxaudionode != NULL)
353                {
354                        if(dmxsetsource(dmxaudionode, fenode->fedmxsource) != 0)
355                        {
356                                dmxclose(dmxaudionode, -1);
357                                dmxaudionode = NULL;
358                        }
359                        if(dmxsetpesfilter(dmxaudionode, chnode->audiopid, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0) != 0)
360                        {
361                                dmxclose(dmxaudionode, -1);
362                                dmxaudionode = NULL;
363                        }
364                }
365                else
366                        err("demux audio dev not ok");
367        }
368        else
369        {
370                err("dmx audiopid not valid (%d)", chnode->audiopid);
371                dmxclose(status.aktservice->dmxaudiodev, -1);
372        }
373
374        status.aktservice->dmxaudiodev = dmxaudionode;
375
376        //demux video start
377        if(chnode->videopid > 0)
378        {
379                if(status.aktservice->dmxvideodev != NULL && status.aktservice->dmxvideodev->fd >= 0 && status.aktservice->dmxvideodev->adapter == fenode->adapter && status.aktservice->dmxvideodev->devnr == fenode->devnr)
380                        dmxvideonode = status.aktservice->dmxvideodev;
381                else
382                {
383                        dmxclose(status.aktservice->dmxvideodev, -1);
384                        dmxvideonode = dmxopen(fenode, 2);
385                        if(dmxsetbuffersize(dmxvideonode, getconfigint("dmxvideobuffersize", NULL)) != 0)
386                        {
387                                dmxclose(dmxvideonode, -1);
388                                dmxvideonode = NULL;
389                        }
390                        status.aktservice->dmxvideodev = dmxvideonode;
391                }
392                if(dmxvideonode != NULL)
393                {
394                        if(dmxsetsource(dmxvideonode, fenode->fedmxsource) != 0)
395                        {
396                                dmxclose(dmxvideonode, -1);
397                                dmxvideonode = NULL;
398                        }
399                        if(dmxsetpesfilter(dmxvideonode, chnode->videopid, -1, DMX_OUT_DECODER, DMX_PES_VIDEO, 0) != 0)
400                        {
401                                dmxclose(dmxvideonode, -1);
402                                dmxvideonode = NULL;
403                        }
404                }
405                else
406                        err("demux video dev not ok");
407        }
408        else
409        {
410                err("dmx videopid not valid (%d)", chnode->videopid);
411                dmxclose(status.aktservice->dmxvideodev, -1);
412        }
413
414        status.aktservice->dmxvideodev = dmxvideonode;
415       
416        //workaround for some audio channel not playing (for test)
417        usleep(100000);
418
419        //audio start
420        if(dmxaudionode != NULL)
421        {
422                if(status.aktservice->audiodev != NULL && status.aktservice->audiodev->fd >= 0 && status.aktservice->audiodev->adapter == fenode->adapter)
423                        audionode = status.aktservice->audiodev;
424                else
425                {
426                        audioclose(status.aktservice->audiodev, -1);
427                        audionode = audioopen(fenode->adapter);
428                        status.aktservice->audiodev = audionode;
429                }
430                if(audionode != NULL)
431                {
432                        audioselectsource(audionode, AUDIO_SOURCE_DEMUX);
433                        audiosetbypassmode(audionode, chnode->audiocodec);
434                        if(checkbox("VUSOLO2") == 1) //fixt only audio no video.. blackscreen after zap
435                                audiopause(audionode);
436                        if(status.mute != 1)
437                                audioplay(audionode);
438                }
439                else
440                        err("can't get free audio dev");
441        }
442       
443        //video start
444        if(dmxvideonode != NULL)
445        {
446                if(status.aktservice->videodev != NULL && status.aktservice->videodev->fd >= 0 && status.aktservice->videodev->adapter == fenode->adapter)
447                        videonode = status.aktservice->videodev;
448                else
449                {
450                        videoclose(status.aktservice->videodev, -1);
451                        videonode = videoopen(fenode->adapter, 0);
452                        status.aktservice->videodev = videonode;
453                }
454                if(videonode != NULL)
455                {
456                        videocontinue(videonode);
457                        videoselectsource(videonode, VIDEO_SOURCE_DEMUX);
458                        setencoding(chnode, videonode);
459                       
460                        if(checkbox("VUSOLO2") == 1) //fixt only audio no video.. blackscreen after zap
461                                videofreeze(videonode);
462               
463                        if(videoplay(videonode)!= 0) {
464                                usleep(500000);
465                                videoplay(videonode);
466                        }
467                }
468                else
469                        err("can't get free video dev");
470        }
471
472#ifdef MIPSEL
473        if(tmpmute == 1)
474        {
475                tmpmute = 0;
476                setmute(1);
477        }
478#else   
479        //unset mute if set here
480        if(tmpmute == 1)
481        {
482                tmpmute = 0;
483                audiosetmute(status.aktservice->audiodev, 0);
484                //setmute(0);
485        }
486        if(status.mute != 1)
487                audioplay(status.aktservice->audiodev);
488#endif
489       
490        //check pmt if not done
491        if(checkpmt == 0)
492        {
493                //wait for tuner lock
494                if(flag == 0)
495                {
496                        if(fenode->felasttransponder != tpnode)
497                                festatus = fewait(fenode);
498                        else
499                        {
500                                festatus = fegetunlock(fenode);
501                                if(festatus != 0)
502                                {
503                                        debug(200, "fegetunlock rc:%d ... now fewait", festatus);       
504                                        festatus = fewait(fenode);
505                                }
506                        }
507
508                        if(debug_level == 200)
509                        {
510                                fereadstatus(fenode);
511                                fegetfrontend(fenode);
512                        }
513                        if(festatus != 0)
514                        {
515                                m_unlock(&status.servicemutex, 2);
516                                return 2;
517                        }
518                }
519
520                checkpmt = 1;
521                patbuf = dvbgetpat(fenode, -1);
522                if(patbuf == NULL) status.secondzap = 3;
523                debug(200, "3-secondzap=%i", status.secondzap);
524                free(status.aktservice->pmtbuf);
525                status.aktservice->pmtbuf = NULL;
526                status.aktservice->pmtlen = 0;
527                if(patbuf != NULL)
528                        status.aktservice->pmtbuf = dvbgetpmt(fenode, patbuf, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 0);
529                else if(chnode->pmtpid > 0)
530                        status.aktservice->pmtbuf = dvbgetpmt(fenode, NULL, chnode->serviceid, &chnode->pmtpid, &status.aktservice->pmtlen, -1, 1);
531
532                if(status.aktservice->pmtbuf == NULL) status.secondzap = 4;
533                debug(200, "4-secondzap=%i", status.secondzap);
534                if(dvbgetinfo(status.aktservice->pmtbuf, chnode) == 1)
535                {
536                        //audio or video pid or codec changed
537                        free(status.aktservice->pmtbuf);
538                        status.aktservice->pmtbuf = NULL;
539                        status.aktservice->pmtlen = -1;
540                }
541
542                if(flag == 0)
543                {
544                        if(status.pmtmode == 1)
545                        {
546                                if(recordcheckcrypt(fenode, CHANNEL) == 0)
547                                        dvbwritepmt(status.aktservice, status.aktservice->pmtbuf);
548                                else
549                                        debug(200, "don't write pmt.tmp, another crypt channel use this frontend");
550                        }
551                        else
552                                sendcapmt(status.aktservice, 0, 0);
553                }
554                free(patbuf);
555        }
556
557        //get ait and parse it for hbbtv url
558        if(flag == 0 && chnode->aitpid > 0)
559        {
560                unsigned char* aitbuf = NULL;
561                aitbuf = dvbgetait(fenode, chnode->aitpid, 0, -1);
562                if(aitbuf != NULL)
563                {
564                        free(chnode->hbbtvurl); chnode->hbbtvurl = NULL;
565                        chnode->hbbtvurl = dvbgethbbtvurl(aitbuf);
566                }
567
568                debug(200, "hbbtvurl=%s", chnode->hbbtvurl);
569                free(aitbuf); aitbuf = NULL;
570        }
571
572        if(flag == 0)
573        {
574                //add channel to history
575                if(status.aktservice->type == CHANNEL)
576                {
577                        addchannelhistory(chnode, status.aktservice->channellist);
578                        if(status.servicetype == 0) //only for tv
579                                createmostzap(chnode->serviceid, chnode->transponderid);
580                }
581                festatus = fewait(fenode);
582                if(festatus != 0)
583                {
584                        m_unlock(&status.servicemutex, 2);
585                        err("festatus=%i", festatus );
586                        return 2;
587                }
588        }
589
590        //wait for epg thread stops
591        if(flag == 0 && status.epgthread != NULL)
592        {
593                i = 0;
594                while(status.epgthread->status != INPAUSE)
595                {
596                        usleep(10000);
597                        i++; if(i > 300) break;
598                }
599                status.epgthread->aktion = START;
600        }
601
602        status.videosizevalid = time(NULL);
603        m_unlock(&status.servicemutex, 2);
604       
605        //auto change channel name
606        if(flag == 0 && status.autochangechannelname == 1)
607                addtimer(&autochangechannelname, START, 1000, 1, NULL, NULL, NULL);
608       
609        //autoresolution
610        if(flag == 0 && ostrcmp(getconfig("av_videomode_autores", NULL), "auto") == 0)
611        {
612                int sec = 7;
613                char* av_videomode_autores_ts = getconfig("av_videomode_autores_ts", NULL);
614                if(av_videomode_autores_ts != NULL)
615                        sec = atoi(av_videomode_autores_ts);
616                if(status.restimer == NULL)
617                        status.restimer = addtimer(&setaktres, START, 1000, 1, (void*)sec, NULL, NULL);
618                else
619                {
620                        status.restimer->aktion = STOP;
621                        status.restimer = addtimer(&setaktres, START, 1000, 1, (void*)sec, NULL, NULL);
622                }                       
623        }
624       
625        if(flag == 0 && status.autosubtitle == 1) subtitlestartlast(); //start subtitle
626        if(flag == 0 && status.timeshifttype == 1)
627        {
628                i = 0;
629                while(status.timeshift > 0)
630                {
631                        usleep(100000);
632                        i++; if(i > 20) break;
633                }
634                timeshiftpause(); //start permanent timeshift record
635        }
636       
637        debug(200, "servicestartreal... ended with 0");
638        return 0;
639}
640
641//second zap on failure
642int servicestart(struct channel* chnode, char* channellist, char* pin, int flag)
643{
644        int ret = 0;
645       
646        ret = servicestartreal(chnode, channellist, pin, flag);
647        debug(200, "servicestart... started");
648        if(status.secondzap != 0 && ret == 0 && (flag == 0 || flag > 2))
649        {
650                debug(200, "first zap not ok, make second zap (%d)", status.secondzap);
651                ret = servicestartreal(chnode, channellist, pin, 6);
652        }
653        debug(200, "servicestart... ended");
654        return ret;
655}
656
657//flag 0: lock
658//flag 1: no lock
659struct service* getservicebyrecname(char* file, int type, int flag)
660{
661        if(file == NULL) return NULL;
662
663        if(flag == 0) m_lock(&status.servicemutex, 2);
664        struct service* snode = service;
665
666        while(snode != NULL)
667        {
668                if(ostrcmp(snode->recname, file) == 0 && (type == 0 || (type == 1 && (snode->type == RECORDDIRECT || snode->type == RECORDTIMER))))
669                {
670                        if(flag == 0) m_unlock(&status.servicemutex, 2);
671                        return snode;
672                }
673                snode = snode->next;
674        }
675        if(flag == 0) m_unlock(&status.servicemutex, 2);
676        return NULL;
677}
678
679struct service* getservicebychannel(struct channel* chnode)
680{
681        m_lock(&status.servicemutex, 2);
682        struct service* snode = service;
683
684        while(snode != NULL)
685        {
686                if(snode->channel == chnode)
687                {
688                        m_unlock(&status.servicemutex, 2);
689                        return snode;
690                }
691                snode = snode->next;
692
693        }
694        m_unlock(&status.servicemutex, 2);
695        return NULL;
696}
697
698//flag 0: lock
699//flag 1: no lock
700struct service* getservicebyrectimestamp(char* timestamp, int flag)
701{
702        if(timestamp == 0) return NULL;
703
704        if(flag == 0) m_lock(&status.servicemutex, 2);
705        struct service* snode = service;
706
707        while(snode != NULL)
708        {
709                if(ostrcmp(snode->rectimestamp, timestamp) == 0)
710                {
711                        if(flag == 0) m_unlock(&status.servicemutex, 2);
712                        return snode;
713                }
714                snode = snode->next;
715        }
716        if(flag == 0) m_unlock(&status.servicemutex, 2);
717        return NULL;
718}
719
720struct service* getservicebyservice(struct service* node, int flag)
721{
722        if(flag == 0) m_lock(&status.servicemutex, 2);
723        struct service* snode = service;
724
725        while(snode != NULL)
726        {
727                if(snode != status.lastservice && snode != node && snode->channel == node->channel)
728                {
729                        if(flag == 0) m_unlock(&status.servicemutex, 2);
730                        return snode;
731                }
732                snode = snode->next;
733        }
734        if(flag == 0) m_unlock(&status.servicemutex, 2);
735        return NULL;
736}
737
738//flag 0: with mutex
739//flag 1: without mutex
740struct service* getservice(int type, int flag)
741{
742        if(flag == 0) m_lock(&status.servicemutex, 2);
743        struct service* snode = service;
744
745        while(snode != NULL)
746        {
747                if(snode->type == type)
748                {
749                        if(flag == 0) m_unlock(&status.servicemutex, 2);
750                        return snode;
751                }
752                snode = snode->next;
753        }
754        if(flag == 0) m_unlock(&status.servicemutex, 2);
755        return NULL;
756}
757
758//flag 0: faststop depends on param faststop
759//flag 1: always normal stop
760//flag 2: from timeshift/player
761//flag 3: same as 0 but no akttolast
762//flag 4: showiframe
763int servicestop(struct service *node, int clear, int flag)
764{
765        int rcret = 0;
766
767        if(node != NULL)
768        {
769                status.tvpic = 0;
770
771                if(status.timeshift == 1 && flag != 2)
772                {
773                        if(status.timeshifttype == 0 && status.asktimeshift == 0)
774                                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);
775
776                        if(rcret == 2) return 1;
777                        timeshiftstop(1);
778                }
779                if(flag != 2 && node->type != NOTHING && node->type != STILLPIC) caservicedel(node, NULL);
780
781
782                truncate("/tmp/ecm.info", 0);
783                unlink("/tmp/pid.info");
784                unlink("/tmp/caids.info");
785               
786                status.videosizevalid = 0;
787
788                if(status.epgthread != NULL) status.epgthread->aktion = PAUSE;
789                subtitlestop(0);
790
791
792                if(node->type == CHANNEL && flag < 2) akttolast();
793
794                if(flag != 2) node->type = NOTHING;
795                if(flag == 4) node->type = STILLPIC;
796               
797                if(checkbox("DM900") == 1)
798                {
799                        videofreeze(status.aktservice->videodev);
800                        dmxstart(status.aktservice->dmxaudiodev);
801                        audioplay(status.aktservice->audiodev);
802                        audiopause(status.aktservice->audiodev);
803                        videoclearbuffer(status.aktservice->videodev);
804                        audioclearbuffer(status.aktservice->audiodev);
805                        videoslowmotion(status.aktservice->videodev, 0);
806                        videofastforward(status.aktservice->videodev, 0);
807                }
808                else
809                {
810                        audiostop(node->audiodev);
811                        if(checkbox("VUSOLO2") == 1) videoclearbuffer(node->videodev);
812                        videostop(node->videodev, clear);
813                }
814
815                int     fastzap = getconfigint("fastzap", NULL);
816
817                if(flag == 3) flag = 0;
818                if(flag == 4 || flag == 1 || (flag == 0 && (fastzap == 0 || fastzap == 2)))
819                {
820                        audioclose(node->audiodev, -1);
821                        node->audiodev = NULL;
822                        dmxstop(node->dmxaudiodev);
823                        dmxclose(node->dmxaudiodev, -1);
824                        node->dmxaudiodev = NULL;
825                }
826               
827                if(flag == 4 || flag == 1 || (flag == 0 && fastzap == 0))
828                {
829                        videoclose(node->videodev, -1);
830                        node->videodev = NULL;
831                        dmxstop(node->dmxvideodev);
832                        dmxclose(node->dmxvideodev, -1);
833                        node->dmxvideodev = NULL;
834                        dmxstop(node->dmxpcrdev);
835                        dmxclose(node->dmxpcrdev, -1);
836                        node->dmxpcrdev = NULL;
837                        dmxstop(node->dmxsubtitledev);
838                        dmxclose(node->dmxsubtitledev, -1);
839                        node->dmxsubtitledev = NULL;
840                }
841                return 0;
842        }
843        return 1;
844}
845
846void servicechangeaudio(struct channel* chnode, struct audiotrack* tracknode)
847{
848        if(chnode == NULL || tracknode == NULL)
849        {
850                err("NULL detect");
851                return;
852        }
853
854        if(chnode->audiopid == tracknode->audiopid && chnode->audiocodec == tracknode->audiocodec)
855                return;
856
857        chnode->audiopid = tracknode->audiopid;
858        chnode->audiocodec = tracknode->audiocodec;
859
860        status.writechannel = 1;
861        audiostop(status.aktservice->audiodev);
862        audiosetbypassmode(status.aktservice->audiodev, chnode->audiocodec);
863        //clear videobuffer on playback for syncing video / audio
864        if(status.playing == 1) videoclearbuffer(status.aktservice->videodev);
865        dmxsetpesfilter(status.aktservice->dmxaudiodev, chnode->audiopid, -1, DMX_OUT_DECODER, DMX_PES_AUDIO, 0);
866
867        //don't start audio play, if we are in timeshift record, but not playing mode
868        if(status.timeshifttype == 0 && status.timeshift == 1 && status.playing == 0) return;
869        if(status.timeshifttype == 1 && status.timeshift == 1 && status.playing == 0 && status.timeshiftpos > 0) return;
870
871        if(status.mute != 1)
872                audioplay(status.aktservice->audiodev);
873}
874
875struct service* addservice(struct service* last)
876{
877        struct service *newnode = NULL, *node = NULL;
878
879        newnode = (struct service*)calloc(1, sizeof(struct service));
880        if(newnode == NULL)
881        {
882                err("no memory");
883                return NULL;
884        }
885
886        newnode->recdstfd = -1;
887        newnode->recsrcfd = -1;
888        newnode->tssize = 188;
889
890        m_lock(&status.servicemutex, 2);
891        node = service;
892        if(node != NULL)
893        {
894                if(last == NULL)
895                {
896                        while(node->next != NULL)
897                                node = node->next;
898                        node->next = newnode;
899                }
900                else
901                        last->next = newnode;
902        }
903        else
904                service = newnode;
905
906        m_unlock(&status.servicemutex, 2);
907        return newnode;
908}
909
910struct service* checkservice(struct service* node)
911{
912        struct service* snode = service;
913
914        while(snode != NULL)
915        {
916                if(snode == node)
917                        return snode;
918                snode = snode->next;
919        }
920        return NULL;
921}
922
923//flag 0: set mutex
924//flag 1: not set mutex
925void delservice(struct service* snode, int flag)
926{
927        m_lock(&status.servicemutex, 2);
928        struct service *node = service, *prev = service;
929        struct rectimer *rectimernode = NULL;
930
931        while(node != NULL)
932        {
933                if(node == snode)
934                {
935                        if(node == service)
936                                service = node->next;
937                        else
938                                prev->next = node->next;
939
940                        dmxclose(node->dmxaudiodev, -1);
941                        dmxclose(node->dmxvideodev, -1);
942                        dmxclose(node->dmxpcrdev, -1);
943                        dmxclose(node->dmxsubtitledev, -1);
944                        audioclose(node->audiodev, -1);
945                        videoclose(node->videodev, -1);
946                        close(node->recdstfd);
947                        close(node->recsrcfd);
948                        caservicedel(node, NULL);
949
950                        //check if a rectimer is joined with a service
951                        if(node->type == RECORDTIMER)
952                        {
953                                if(flag == 0)
954                                        m_lock(&status.rectimermutex, 1);
955
956                                rectimernode = getrectimerbyservice(node);
957                                if(rectimernode != NULL)
958                                {
959                                        rectimernode->servicenode = NULL;
960                                        if(rectimernode->status == 0 || rectimernode->status == 1)
961                                        {
962                                                rectimernode->status = 2;
963                                                status.writerectimer = 1;
964                                                writerectimer(getconfig("rectimerfile", NULL), 1);
965                                        }
966                                }
967
968                                if(flag == 0)
969                                        m_unlock(&status.rectimermutex, 1);
970                        }
971
972                        free(node->channellist);
973                        node->channellist = NULL;
974
975                        free(node->recname);
976                        node->recname = NULL;
977
978                        free(node->rectimestamp);
979                        node->rectimestamp = NULL;
980
981                        free(node->pmtbuf);
982                        node->pmtbuf = NULL;
983
984                        free(node);
985                        node = NULL;
986                        break;
987                }
988
989                prev = node;
990                node = node->next;
991        }
992        m_unlock(&status.servicemutex, 2);
993}
994
995void freeservice()
996{
997        struct service *node = service, *prev = service;
998
999        while(node != NULL)
1000        {
1001                prev = node;
1002                node = node->next;
1003                if(prev != NULL)
1004                        delservice(prev, 0);
1005        }
1006}
1007
1008char* servicecheckret(int ret, int flag)
1009{
1010        char* tmpstr = NULL;
1011
1012        if(ret != 0)
1013        {
1014                switch(ret)
1015                {
1016                        case 1:
1017                                tmpstr = ostrcat(_("Can't find a Tuner.\nAll Tuners in use or no Tuner defined."), NULL, 0, 0);
1018                                break;
1019                        case 2:
1020                                tmpstr = ostrcat(_("Tuning to Channel failed!"), NULL, 0, 0);
1021                                break;
1022                        case 3:
1023                                tmpstr = ostrcat(_("Can't open frontend dev or Frontend Type unknown!"), NULL, 0, 0);
1024                                break;
1025                        case 20:
1026                                break;
1027                        case 21:
1028                                tmpstr = ostrcat(_("Channellist empty or corrupt (channel not found)!"), NULL, 0, 0);
1029                                break;
1030                        case 22:
1031                                break;
1032                }
1033                if(tmpstr != NULL)
1034                        textbox(_("Message"), tmpstr, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
1035        }
1036
1037        if(flag != 1)
1038        {
1039                free(tmpstr);
1040                tmpstr = NULL;
1041        }
1042
1043        return tmpstr;
1044}
1045
1046#ifdef MIPSEL
1047void servicefullHDMIin_start()
1048{
1049        struct dvbdev *videonode = NULL;
1050        struct dvbdev *audionode = NULL;
1051        struct channel *chnode = NULL;
1052       
1053        servicestop(status.aktservice, 1, 1);
1054       
1055        audionode = audioopen(0);
1056        if(audionode != NULL)
1057        {
1058                audioselectsource(audionode, AUDIO_SOURCE_HDMI);
1059                audioplay(audionode);
1060        }
1061        videonode = videoopen(0, 0);
1062        if(videonode != NULL)
1063        {
1064                videoselectsource(videonode, VIDEO_SOURCE_HDMI);
1065                videosetstreamtype(videonode, 0);
1066                videoplay(videonode);
1067        }
1068        status.aktservice->videodev = videonode;
1069        status.aktservice->audiodev = audionode;
1070        status.aktservice->type = HDMIIN;
1071        chnode = getchannel(65535, 0);
1072        if(chnode == NULL)
1073                //chnode = createchannel("HDMIIN", 0, 0, 65535, 99, 0, -1, -1, -1, -1, 0, -1);
1074                chnode = createchannel("HDMIIN", 0, 0, 65535, 0, 0, -1, -1, -1, -1, 0, -1);
1075        status.aktservice->channel = chnode;
1076}
1077#endif
1078
1079#endif
Note: See TracBrowser for help on using the repository browser.