source: titan/titan/service.h @ 27899

Last change on this file since 27899 was 26992, checked in by gost, 10 years ago

mipsel delete unneeded code

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