source: titan/titan/channel.h @ 23095

Last change on this file since 23095 was 23095, checked in by nit, 11 years ago

STARTFUNC

File size: 14.8 KB
Line 
1#ifndef CHANNEL_H
2#define CHANNEL_H
3
4void debugchannel()
5{
6        STARTFUNC
7        struct channel* node = channel;
8
9        while(node != NULL)
10        {
11                printf("%s %p <%p >%p\n", node->name, node, node->prev, node->next);
12                node = node->next;
13        }
14}
15
16int channelnottunable(struct channel* node)
17{
18        STARTFUNC
19        if(node == NULL) return 1;
20        if(node->transponder == NULL) return 1;
21        if(node->transponder->tunablestatus == 0)
22        {
23                if(fegetfree(node->transponder, 1, NULL) == NULL)
24                {
25                        node->transponder->tunablestatus = 2;
26                        return 1;
27                }
28                else
29                {
30                        node->transponder->tunablestatus = 1;
31                        return 0;
32                }
33        }
34        else if(node->transponder->tunablestatus == 2)
35                return 1;
36
37        return 0;
38}
39
40//flag 0: lock
41//flag 1: no lock
42struct channel* getlastchannel(struct channel* node, int flag)
43{
44        STARTFUNC
45        struct channel *prev = NULL;
46
47        if(flag == 0) m_lock(&status.channelmutex, 5);
48        while(node != NULL)
49        {
50                prev = node;
51                node = node->next;
52        }
53        if(flag == 0) m_unlock(&status.channelmutex, 5);
54
55        return prev;
56}
57
58struct channel* gettmpchannel()
59{
60        STARTFUNC
61
62        m_lock(&status.channelmutex, 5);
63  struct channel *node = channel;
64 
65        while(node != NULL)
66        {
67                if(node->servicetype == 99)
68                        break;
69                node = node->next;
70        }
71        m_unlock(&status.channelmutex, 5);
72
73        return node;
74}
75
76struct channel* getprevchannelbyservicetype(struct channel* node)
77{
78        STARTFUNC
79        struct channel* prev = NULL;
80
81        if(node == NULL) node = channel;
82        if(node == NULL) return NULL;
83
84        prev = node->prev;
85        while(prev != NULL && prev->servicetype != status.servicetype)
86                prev = prev->prev;
87        if(prev == NULL)
88        {
89                prev = getlastchannel(channel, 0);
90                while(prev != NULL && prev->servicetype != status.servicetype)
91                        prev = prev->prev;
92        }
93
94        return prev;
95}
96
97struct channel* getnextchannelbyservicetype(struct channel* node)
98{
99        STARTFUNC
100        struct channel* next = NULL;
101
102        if(node == NULL) node = channel;
103        if(node == NULL) return NULL;
104
105        next = node->next;
106
107        while(next != NULL && next->servicetype != status.servicetype)
108                next = next->next;
109        if(next == NULL)
110        {
111                next = channel;
112                while(next != NULL && next->servicetype != status.servicetype)
113                        next = next->next;
114        }
115
116        return next;
117}
118
119int movechannelblockdown(struct channel* node)
120{
121        STARTFUNC
122        int i = 0, ret = 0;
123        struct channel* prev = NULL;
124
125        if(node == NULL || channel == NULL) return 1;
126
127        for(i = 0; i < status.moveblockcount; i++)
128        {
129                if(node == NULL) break;
130                node = node->next;
131                while(node != NULL && node->servicetype != status.servicetype)
132                        node = node->next;
133        }
134
135        for(i = 0; i < status.moveblockcount + 1; i++)
136        {
137                if(node == NULL) break;
138                prev = getprevchannelbyservicetype(node);
139                ret = movechanneldown(node);
140
141                while(node->prev != NULL && node->prev->servicetype != status.servicetype)
142                        ret = movechanneldown(node);
143
144                node = prev;
145        }
146
147        return ret;
148}
149
150int movechanneldown(struct channel* node)
151{
152        STARTFUNC
153        struct channel* prev = NULL, *next = NULL;
154
155        if(node == NULL || channel == NULL) return 1;
156
157        m_lock(&status.channelmutex, 5);
158
159        //last node
160        if(node->next == NULL)
161        {
162                if(node->prev != NULL)
163                        node->prev->next = NULL;
164                node->prev = NULL;
165                node->next = channel;
166                channel->prev = node;
167                channel = node;
168                m_unlock(&status.channelmutex, 5);
169                return 99;
170        }
171
172        //haenge node aus
173        if(node->prev != NULL)
174                node->prev->next = node->next;
175        else
176                channel = node->next;
177        node->next->prev = node->prev;
178
179        //save nodes next and prev
180        next = node->next;
181        prev = node->prev;
182
183        //haenge es eine pos nacher ein
184        node->next = next->next;
185        node->prev = next;
186       
187        if(next->next != NULL)
188                next->next->prev = node;
189        next->next = node;
190
191        m_unlock(&status.channelmutex, 5);
192
193        status.writechannel = 1;
194        return 0;
195}
196
197int movechannelblockup(struct channel* node)
198{
199        STARTFUNC
200        int i = 0, ret = 0;
201        struct channel* next = NULL;
202
203        if(node == NULL || channel == NULL) return 1;
204
205        for(i = 0; i < status.moveblockcount + 1; i++)
206        {
207                if(node == NULL) break;
208                next = getnextchannelbyservicetype(node);
209                ret = movechannelup(node);
210
211                while(node->next != NULL && node->next->servicetype != status.servicetype)
212                        ret = movechannelup(node);
213
214                node = next;
215        }
216
217        return ret;
218}
219
220int movechannelup(struct channel* node)
221{
222        STARTFUNC
223        struct channel* prev = NULL, *next = NULL, *last = NULL;
224
225        if(node == NULL || channel == NULL) return 1;
226
227        m_lock(&status.channelmutex, 5);
228
229        //first node
230        if(node->prev == NULL)
231        {
232                last = getlastchannel(channel, 1);
233
234                if(node->next != NULL)
235                        node->next->prev = NULL;
236                channel = node->next;
237                node->next = NULL;
238                last->next = node;
239                node->prev = last;
240                m_unlock(&status.channelmutex, 5);
241                return 99;
242        }
243
244        //haenge node aus
245        node->prev->next = node->next;
246        if(node->next != NULL)
247                node->next->prev = node->prev;
248
249        //save nodes next and prev
250        next = node->next;
251        prev = node->prev;
252
253        //haenge es eine pos voher ein
254        node->next = prev;
255        node->prev = prev->prev;
256       
257        if(prev->prev != NULL)
258                prev->prev->next = node;
259        else
260                channel = node;
261        prev->prev = node;
262
263        m_unlock(&status.channelmutex, 5);
264
265        status.writechannel = 1;
266        return 0;
267}
268
269struct channel* addchannel(char *line, int count, struct channel* last)
270{
271        STARTFUNC
272        struct channel *newnode = NULL, *prev = NULL, *node = NULL;
273        char *name = NULL;
274        int ret = 0;
275
276        if(line == NULL) return NULL;
277
278        newnode = (struct channel*)calloc(1, sizeof(struct channel));
279        if(newnode == NULL)
280        {
281                err("no memory");
282                return NULL;
283        }
284
285        name = malloc(MINMALLOC);
286        if(name == NULL)
287        {
288                err("no memory");
289                free(newnode);
290                return NULL;
291        }
292
293        ret = sscanf(line, "%[^#]#%llu#%d#%d#%d#%"SCNu8"#%"SCNu8"#%"SCNu8"#%"SCNu16"#%"SCNu16"#%"SCNu8, name, &newnode->transponderid, &newnode->providerid, &newnode->serviceid, &newnode->servicetype, &newnode->flag, &newnode->videocodec, &newnode->audiocodec, &newnode->videopid, &newnode->audiopid, &newnode->protect);
294        if(ret != 11 || getchannel(newnode->serviceid, newnode->transponderid) != NULL)
295        {
296                if(count > 0)
297                {
298                        err("channellist line %d not ok or double", count);
299                }
300                else
301                {
302                        err("add channel");
303                }
304                free(name);
305                free(newnode);
306                return NULL;
307        }
308
309        newnode->name = ostrshrink(name);
310        //99 = tmp channel
311        if(newnode->servicetype != 99)
312        {
313                newnode->transponder = gettransponder(newnode->transponderid);
314                newnode->provider = getprovider(newnode->providerid);
315                status.writechannel = 1;
316        }
317
318        m_lock(&status.channelmutex, 5);
319        node = channel;
320
321        modifychannelcache(newnode->serviceid, newnode->transponderid, newnode);
322
323        if(last == NULL)
324        {
325                while(node != NULL && strcasecmp(newnode->name, node->name) > 0)
326                {
327                        prev = node;
328                        node = node->next;
329                }
330        }
331        else
332        {
333                prev = last;
334                node = last->next;
335        }
336
337        if(prev == NULL)
338                channel = newnode;
339        else
340        {
341                prev->next = newnode;
342                newnode->prev = prev;
343        }
344        newnode->next = node;
345        if(node != NULL) node->prev = newnode;
346       
347        m_unlock(&status.channelmutex, 5);
348        return newnode;
349}
350
351struct channel* createchannel(char* name, uint64_t transponderid, int providerid, int serviceid, int servicetype, int flag, int videocodec, int audiocodec, int videopid, int audiopid, int protect)
352{
353        STARTFUNC
354        struct channel* chnode = NULL;
355        char* tmpstr = NULL;
356
357        tmpstr = ostrcat(tmpstr, name, 1, 0);
358        tmpstr = ostrcat(tmpstr, "#", 1, 0);
359        tmpstr = ostrcat(tmpstr, ollutoa(transponderid), 1, 1);
360        tmpstr = ostrcat(tmpstr, "#", 1, 0);
361        tmpstr = ostrcat(tmpstr, oitoa(providerid), 1, 1);
362        tmpstr = ostrcat(tmpstr, "#", 1, 0);
363        tmpstr = ostrcat(tmpstr, oitoa(serviceid), 1, 1);
364        tmpstr = ostrcat(tmpstr, "#", 1, 0);
365        tmpstr = ostrcat(tmpstr, oitoa(servicetype), 1, 1);
366        tmpstr = ostrcat(tmpstr, "#", 1, 0);
367        tmpstr = ostrcat(tmpstr, oitoa(flag), 1, 1);
368        tmpstr = ostrcat(tmpstr, "#", 1, 0);
369        tmpstr = ostrcat(tmpstr, oitoa(videocodec), 1, 1);
370        tmpstr = ostrcat(tmpstr, "#", 1, 0);
371        tmpstr = ostrcat(tmpstr, oitoa(audiocodec), 1, 1);
372        tmpstr = ostrcat(tmpstr, "#", 1, 0);
373        tmpstr = ostrcat(tmpstr, oitoa(videopid), 1, 1);
374        tmpstr = ostrcat(tmpstr, "#", 1, 0);
375        tmpstr = ostrcat(tmpstr, oitoa(audiopid), 1, 1);
376        tmpstr = ostrcat(tmpstr, "#", 1, 0);
377        tmpstr = ostrcat(tmpstr, oitoa(protect), 1, 1);
378
379        chnode = addchannel(tmpstr, 1, NULL);
380
381        free(tmpstr);
382        return chnode;
383}
384
385int readchannel(const char* filename)
386{
387        STARTFUNC
388        FILE *fd = NULL;
389        char *fileline = NULL;
390        int linecount = 0, len = 0;
391        struct channel* last = NULL, *tmplast = NULL;
392
393        fileline = malloc(MINMALLOC);
394        if(fileline == NULL)
395        {
396                err("no memory");
397                return 1;
398        }
399
400        fd = fopen(filename, "r");
401        if(fd == NULL)
402        {
403                perr("can't open %s", filename);
404                free(fileline);
405                return 1;
406        }
407
408        while(fgets(fileline, MINMALLOC, fd) != NULL)
409        {
410                if(fileline[0] == '#' || fileline[0] == '\n')
411                        continue;
412                len = strlen(fileline) - 1;
413                if(len >= 0 && fileline[len] == '\n')
414                        fileline[len] = '\0';
415                len--;
416                if(len >= 0 && fileline[len] == '\r')
417                        fileline[len] = '\0';
418
419                linecount++;
420
421                if(last == NULL) last = tmplast;
422                last = addchannel(fileline, linecount, last);
423                if(last != NULL) tmplast = last;
424        }
425
426        status.writechannel = 0;
427        free(fileline);
428        fclose(fd);
429        return 0;
430}
431
432//flag 0: del bouquet
433//flag 1: don't del bouquet
434int delchannel(int serviceid, uint64_t transponderid, int flag)
435{
436        STARTFUNC
437        int ret = 1;
438        struct provider* providernode = NULL;
439
440        m_lock(&status.channelmutex, 5);
441  struct channel *node = channel, *prev = channel;
442
443        while(node != NULL)
444        {
445                if(node->serviceid == serviceid && node->transponderid == transponderid && getservicebychannel(node) == NULL)
446                {
447                        ret = 0;
448                        if(node->servicetype != 99) status.writechannel = 1;
449                        if(node == channel)
450                        {
451                                channel = node->next;
452                                if(channel != NULL)
453                                        channel->prev = NULL;
454                        }
455                        else
456                        {
457                                prev->next = node->next;
458                                if(node->next != NULL)
459                                        node->next->prev = prev;
460                        }
461
462                        if(flag == 0)
463                        {
464                                delbouquetbychannel(node->serviceid, node->transponderid);
465                                delepgscanlist(node->serviceid, node->transponderid);
466                        }
467                        else
468                                setbouquetchanneltonullmain(node->serviceid, node->transponderid);
469
470                        providernode = node->provider;
471                        delchannelcache(node->serviceid, node->transponderid);
472                        delchannelhistory(node);
473                        delmostzap(node->serviceid, node->transponderid, 0);
474
475                        freeaudiotrack(node);
476                        free(node->audiotrack);
477                        node->audiotrack = NULL;
478
479                        freesubtitle(node);
480                        free(node->subtitle);
481                        node->subtitle = NULL;
482                       
483                        freelinkedchannel(node);
484                        free(node->linkedchannel);
485                        node->linkedchannel = NULL;
486
487                        freepmt(node);
488                        free(node->pmt);
489                        node->pmt = NULL;
490
491                        freecadesc(node);
492                        free(node->cadesc);
493                        node->cadesc = NULL;
494
495                        freeesinfo(node);
496                        free(node->esinfo);
497                        node->esinfo = NULL;
498
499                        freeepg(node);
500                        node->epg = NULL;
501
502                        free(node->name);
503                        node->name = NULL;
504     
505      free(node->hbbtvurl);
506      node->hbbtvurl = NULL;
507
508                        free(node);
509                        node = NULL;
510
511                        delprovidernotused(providernode);
512                        break;
513                }
514
515                prev = node;
516                node = node->next;
517        }
518
519        recalcbouquetnr();
520        m_unlock(&status.channelmutex, 5);
521        return ret;
522}
523
524void delchannelbytransponder(uint64_t transponderid)
525{
526        STARTFUNC
527        struct channel *node = channel, *prev = channel;
528
529        while(node != NULL)
530        {
531                prev = node;
532                node = node->next;
533                if(prev != NULL && prev->transponderid == transponderid)
534                        delchannel(prev->serviceid, prev->transponderid, 0);
535        }
536}
537
538//flag 0: del bouquet
539//flag 1: don't del bouquet
540void freechannel(int flag)
541{
542        STARTFUNC
543        struct channel *node = channel, *prev = channel;
544
545        while(node != NULL)
546        {
547                prev = node;
548                node = node->next;
549                if(prev != NULL)
550                        delchannel(prev->serviceid, prev->transponderid, flag);
551        }
552}
553
554/*
555struct channel* sortchannel()
556{
557        STARTFUNC
558        struct channel *node = channel;
559        struct channel *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
560        struct channel *nodetmp = NULL;
561
562        if(node == NULL) return NULL;
563       
564        struct channel **nodeaddr = &channel;
565
566        if(node != NULL)
567        {
568                while(noded != node->next)
569                {
570                        nodec = node;
571                        nodea = node;
572                        nodeb = nodea->next;
573
574                        while(nodea != noded)
575                        {
576                                if(strcasecmp(nodea->name, nodeb->name) > 0)
577                                {
578                                        if(nodea == node)
579                                        {
580                                                nodetmp = nodeb->next;
581                                                nodeb->next = nodea;
582                                                nodea->next = nodetmp;
583                                                node = nodeb;
584                                                *nodeaddr = nodeb;
585                                                nodec = nodeb;
586                                        }
587                                        else
588                                        {
589                                                nodetmp = nodeb->next;
590                                                nodeb->next = nodea;
591                                                nodea->next = nodetmp;
592                                                nodec->next = nodeb;
593                                                nodec = nodeb;
594                                        }
595                                }
596                                else
597                                {
598                                        nodec = nodea;
599                                        nodea = nodea->next;
600                                }
601                                nodeb = nodea->next;
602                                if (nodeb == noded)
603                                        noded = nodea;
604                        }
605                }
606        }
607
608        //calc prev
609        struct channel* prev = NULL;
610        nodetmp = node;
611        while(nodetmp != NULL)
612        {
613                nodetmp->prev = prev;
614                prev = nodetmp;
615
616                nodetmp = nodetmp->next;
617        }
618
619        status.writechannel = 1;
620        return channel;
621}
622*/
623
624struct channel* sortchannel()
625{
626        STARTFUNC
627        struct channel* tmpnode[10] = {0};
628        struct channel* node = channel, *tnode = NULL;
629        struct channel *next = NULL, *prev = NULL;
630        struct channel **tnodeaddr = NULL;
631       
632        if(node == NULL) return NULL;
633
634        while(node != NULL)
635        {
636                next = node->next;
637                prev = NULL;
638
639                if(strcasecmp("c", node->name) > 0) {tnode = tmpnode[0]; tnodeaddr = &tmpnode[0];}
640                else if(strcasecmp("f", node->name) > 0) {tnode = tmpnode[1]; tnodeaddr = &tmpnode[1];}
641                else if(strcasecmp("i", node->name) > 0) {tnode = tmpnode[2]; tnodeaddr = &tmpnode[2];}
642                else if(strcasecmp("l", node->name) > 0) {tnode = tmpnode[3]; tnodeaddr = &tmpnode[3];}
643                else if(strcasecmp("o", node->name) > 0) {tnode = tmpnode[4]; tnodeaddr = &tmpnode[4];}
644                else if(strcasecmp("r", node->name) > 0) {tnode = tmpnode[5]; tnodeaddr = &tmpnode[5];}
645                else if(strcasecmp("u", node->name) > 0) {tnode = tmpnode[6]; tnodeaddr = &tmpnode[6];}
646                else if(strcasecmp("x", node->name) > 0) {tnode = tmpnode[7]; tnodeaddr = &tmpnode[7];}
647                else if(strcasecmp("z", node->name) > 0) {tnode = tmpnode[8]; tnodeaddr = &tmpnode[8];}
648                else {tnode = tmpnode[9]; tnodeaddr = &tmpnode[9];}
649
650                while(tnode != NULL && strcasecmp(node->name, tnode->name) > 0)
651                {
652                        prev = tnode;
653                        tnode = tnode->next;
654                }
655
656                if(prev == NULL)
657                {
658                        *tnodeaddr = node;
659                        node->prev = NULL;
660                }
661                else
662                {
663                        prev->next = node;
664                        node->prev = prev;
665                }
666                node->next = tnode;
667                if(tnode != NULL) tnode->prev = node;
668
669                node = next;
670        }
671
672        int i = 0, first = 0;
673        prev = NULL; node = NULL;
674        for(i = 0; i < 10; i++)
675        {
676                if(tmpnode[i] != NULL)
677                {
678                        if(prev != NULL)
679                        {
680                                prev->next = tmpnode[i];
681                                tmpnode[i]->prev = prev;
682                        }
683
684                        if(first == 0)
685                        {
686                                channel = tmpnode[i];
687                                first = 1;
688                        }
689
690                        node = tmpnode[i];
691                        while(node != NULL)
692                        {
693                                prev = node;
694                                node = node->next;
695                        }
696                }
697        }
698
699        status.writechannel = 1;
700        return channel;
701}
702
703int writechannel(const char *filename)
704{
705        STARTFUNC
706        FILE *fd = NULL;
707        struct channel *node = NULL;
708        int ret = 0;
709
710        fd = fopen(filename, "w");
711        if(fd == NULL)
712        {
713                perr("can't open %s", filename);
714                return 1;
715        }
716
717        m_lock(&status.channelmutex, 5);
718        node = channel;
719
720        while(node != NULL)
721        {
722                if(node->servicetype == 99)
723                {
724                        node = node->next;
725                        continue;
726                }
727                ret = fprintf(fd, "%s#%llu#%d#%d#%d#%d#%d#%d#%d#%d#%d\n", node->name, node->transponderid, node->providerid, node->serviceid, node->servicetype, node->flag, node->videocodec, node->audiocodec, node->videopid, node->audiopid, node->protect);
728                if(ret < 0)
729                {
730                        perr("writting file %s", filename);
731                }
732                node = node->next;
733        }
734        m_unlock(&status.channelmutex, 5);
735
736        fclose(fd);
737        return 0;
738}
739
740#endif
Note: See TracBrowser for help on using the repository browser.