source: titan/titan/eit.h @ 22550

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

fix

File size: 38.4 KB
Line 
1#ifndef EIT_H
2#define EIT_H
3
4void debugepg()
5{
6        struct channel* chnode = channel;
7        struct epg* epgnode = NULL;
8
9        while(chnode != NULL)
10        {
11                if(chnode->epg != NULL)
12                {
13                        printf("\nChannel %s\n", chnode->name);
14                        epgnode = chnode->epg;
15                        while(epgnode != NULL)
16                        {
17                                printf("EventID: %d\n", epgnode->eventid);
18                                printf("Start: %ld\n", epgnode->starttime);
19                                printf("Stop: %ld\n", epgnode->endtime);
20                                printf("Title: %s\n", epgnode->title);
21                                printf("Subtitle: %s\n", epgnode->subtitle);
22                                //printf("Desc: %s\n", epgnode->desc);
23                                epgnode = epgnode->next;
24                        }
25                        printf("\n");
26                }
27                chnode = chnode->next;
28        }
29}
30
31char* createwriteepg(int* buflen)
32{
33        struct channel *chnode = channel;
34        struct epg* epgnode = NULL;
35        char* buf = NULL;
36        int len = 0, newlen = 0;
37
38        m_lock(&status.epgmutex, 4);
39
40        while(chnode != NULL)
41        {
42                epgnode = chnode->epg;
43                while(epgnode != NULL)
44                {
45                        if(*buflen + (MINMALLOC * 2) >= newlen)
46                        {
47                                newlen = *buflen + (MINMALLOC * 100);
48                                buf = realloc(buf, newlen);
49                                if(buf == NULL)
50                                {
51                                        err("no mem");
52                                        *buflen = 0;
53                                        m_unlock(&status.epgmutex, 4);
54                                        return NULL;
55                                }
56                        }
57
58                        memcpy(buf + *buflen, &chnode->serviceid, sizeof(int));
59                        *buflen += sizeof(int);
60                        memcpy(buf + *buflen, &chnode->transponderid, sizeof(uint64_t));
61                        *buflen += sizeof(uint64_t);
62                        memcpy(buf + *buflen, &epgnode->eventid, sizeof(int));
63                        *buflen += sizeof(int);
64                        memcpy(buf + *buflen, &epgnode->version, sizeof(int));
65                        *buflen += sizeof(int);
66                        memcpy(buf + *buflen, &epgnode->parentalrating, sizeof(int));
67                        *buflen += sizeof(int);
68                        memcpy(buf + *buflen, &epgnode->starttime, sizeof(time_t));
69                        *buflen += sizeof(int);
70                        memcpy(buf + *buflen, &epgnode->endtime, sizeof(time_t));
71                        *buflen += sizeof(int);
72
73                        len = 0;
74                        if(epgnode->title != NULL)
75                                len = strlen(epgnode->title);
76                        memcpy(buf + *buflen, &len, sizeof(int));
77                        *buflen += sizeof(int);
78                        if(epgnode->title != NULL && len > 0)
79                        {
80                                memcpy(buf + *buflen, epgnode->title, len);
81                                *buflen += len;
82                        }
83
84                        len = 0;
85                        if(epgnode->subtitle != NULL)
86                                len = strlen(epgnode->subtitle);
87                        memcpy(buf + *buflen, &len, sizeof(int));
88                        *buflen += sizeof(int);
89                        if(epgnode->subtitle != NULL && len > 0)
90                        {
91                                memcpy(buf + *buflen, epgnode->subtitle, len);
92                                *buflen += len;
93                        }
94
95                        if(epgnode->desc == NULL)
96                        {
97                                epgnode->desclen = 0;
98                                epgnode->desccomplen = 0;
99                        }
100                        memcpy(buf + *buflen, &epgnode->desclen, sizeof(int));
101                        *buflen += sizeof(int);
102                        memcpy(buf + *buflen, &epgnode->desccomplen, sizeof(int));
103                        *buflen += sizeof(int);
104
105                        len = epgnode->desccomplen;
106                        if(len == 0)
107                                len = epgnode->desclen;
108                        if(epgnode->desc != NULL)
109                        {
110                                memcpy(buf + *buflen, epgnode->desc, len);
111                                *buflen += len;
112                        }
113
114                        epgnode = epgnode->next;
115                }
116
117                chnode = chnode->next;
118        }
119
120        m_unlock(&status.epgmutex, 4);
121        return buf;
122}
123
124int writeepgfast(const char* filename, char* buf, int buflen)
125{
126        debug(1000, "in");
127        FILE *fd = NULL;
128        int ret;
129
130        if(buf == NULL || buflen == 0) return 1;
131
132        fd = fopen(filename, "wbt");
133        if(fd == NULL)
134        {
135                perr("can't open %s", filename);
136                return 1;
137        }
138
139        unsigned long long freespace = getfreespace((char*)filename);
140        unsigned long long epgfreespace = getconfigint("epgfreespace", NULL) * 1024;
141
142        if(freespace - buflen < epgfreespace)
143        {
144                err("fastwrite out of space freespace=%llu epgfreespace=%llu (%s)", freespace - buflen, epgfreespace, filename);
145                fclose(fd);
146                return 1;
147        }
148
149        ret = fwrite(buf, buflen, 1, fd);
150
151        if(ret != 1)
152        {
153                perr("fast writting file %s", filename);
154                fclose(fd);
155                return 1;
156        }
157
158        fclose(fd);
159        debug(1000, "out");
160        return 0;
161}
162
163int writeepgslow(const char* filename)
164{
165        debug(1000, "in");
166        FILE *fd = NULL;
167        struct channel *chnode = channel;
168        struct epg* epgnode = NULL;
169        int ret = 0, len = 0, count = 0, checkcount = 0, err = 0;
170       
171        m_lock(&status.epgmutex, 4);
172
173        fd = fopen(filename, "wbt");
174        if(fd == NULL)
175        {
176                perr("can't open %s", filename);
177                m_unlock(&status.epgmutex, 4);
178                return 1;
179        }
180
181        unsigned long long freespace = getfreespace((char*)filename);
182        unsigned long long epgfreespace = getconfigint("epgfreespace", NULL) * 1024;
183
184        while(chnode != NULL)
185        {
186                epgnode = chnode->epg;
187                while(epgnode != NULL)
188                {       
189                        ret = 0, count = 0;
190                        ret += fwrite(&chnode->serviceid, sizeof(int), 1, fd); count++;
191                        freespace -= sizeof(int);
192                        ret += fwrite(&chnode->transponderid, sizeof(uint64_t), 1, fd); count++;
193                        freespace -= sizeof(uint64_t);
194                        ret += fwrite(&epgnode->eventid, sizeof(int), 1, fd); count++;
195                        freespace -= sizeof(int);
196                        ret += fwrite(&epgnode->version, sizeof(int), 1, fd); count++;
197                        freespace -= sizeof(int);
198                        ret += fwrite(&epgnode->parentalrating, sizeof(int), 1, fd); count++;
199                        freespace -= sizeof(int);
200                        ret += fwrite(&epgnode->starttime, sizeof(time_t), 1, fd); count++;
201                        freespace -= sizeof(time_t);
202                        ret += fwrite(&epgnode->endtime, sizeof(time_t), 1, fd); count++;
203                        freespace -= sizeof(time_t);
204
205                        len = 0;
206                        if(epgnode->title != NULL)
207                                len = strlen(epgnode->title);
208                        ret += fwrite(&len, sizeof(int), 1, fd); count++;
209                        freespace -= sizeof(int);
210                        if(epgnode->title != NULL && len > 0)
211                        {
212                                ret += fwrite(epgnode->title, len, 1, fd);
213                                freespace -= len;
214                                count++;
215                        }
216
217                        len = 0;
218                        if(epgnode->subtitle != NULL)
219                                len = strlen(epgnode->subtitle);
220                        ret += fwrite(&len, sizeof(int), 1, fd); count++;
221                        freespace -= sizeof(int);
222                        if(epgnode->subtitle != NULL && len > 0)
223                        {
224                                ret += fwrite(epgnode->subtitle, len, 1, fd);
225                                freespace -= len;
226                                count++;
227                        }
228
229                        if(epgnode->desc == NULL)
230                        {
231                                epgnode->desclen = 0;
232                                epgnode->desccomplen = 0;
233                        }
234                        ret += fwrite(&epgnode->desclen, sizeof(int), 1, fd); count++;
235                        freespace -= sizeof(int);
236                        ret += fwrite(&epgnode->desccomplen, sizeof(int), 1, fd); count++;
237                        freespace -= sizeof(int);
238
239                        len = epgnode->desccomplen;
240                        if(len == 0)
241                                len = epgnode->desclen;
242                        if(epgnode->desc != NULL)
243                        {
244                                ret += fwrite(epgnode->desc, len, 1, fd);
245                                freespace -= len;
246                                count++;
247                        }
248
249                        if(ret != count)
250                        {
251                                perr("writting file %s", filename);
252                                if(errno == ENOSPC)
253                                {
254                                        err = 1;
255                                        break;
256                                }
257                        }
258                       
259                        //recheck freespace
260                        checkcount++;
261                        if(checkcount > 10)
262                        {
263                                checkcount = 0;
264                                freespace = getfreespace((char*)filename);
265                        }
266
267                        if(freespace < epgfreespace)
268                                break;
269                        epgnode = epgnode->next;
270                }
271                if(err == 1) break;
272                if(freespace < epgfreespace)
273                {
274                        err("not all data written freespace=%llu epgfreespace=%llu (%s)", freespace, epgfreespace, filename);
275                        break;
276                }
277                chnode = chnode->next;
278        }
279
280        fclose(fd);
281        if(err == 1) unlink(filename);
282        debug(1000, "out");
283        m_unlock(&status.epgmutex, 4);
284        return 0;
285}
286
287int writeepg(const char* filename)
288{
289        int ret = 0, buflen = 0;
290        char* buf = NULL;
291
292        buf = createwriteepg(&buflen);
293        if(buf != NULL)
294        {
295                ret = writeepgfast(filename, buf, buflen);
296                free(buf); buf = NULL;
297   
298    if(ret != 0) ret = writeepgslow(filename);
299        }
300        else
301                ret = writeepgslow(filename);
302
303        return ret;
304}
305
306char* epgdescunzip(struct epg* epgnode)
307{
308        int ret = 0, zlen = 0;
309        char* zbuf = NULL;
310
311        if(epgnode == NULL)
312        {
313                debug(1000, "out -> NULL detect");
314                return NULL;
315        }
316
317        if(epgnode->desccomplen < 1)
318                return ostrcat(epgnode->desc, NULL, 0, 0);
319
320        ret = ounzip(epgnode->desc, epgnode->desccomplen, &zbuf, &zlen, MINMALLOC, 0);
321        if(ret == 0)
322                return zbuf;
323
324        return NULL;
325}
326
327struct epg* getepgbytime(struct channel* chnode, time_t akttime)
328{
329        debug(1000, "in");
330
331        m_lock(&status.epgmutex, 4);
332
333        if(chnode == NULL || chnode->epg == NULL)
334        {
335                debug(1000, "out-> NULL detect");
336                m_unlock(&status.epgmutex, 4);
337                return NULL;
338        }
339
340        struct epg *node = chnode->epg;
341
342        while(node != NULL)
343        {
344                if(node->starttime <= akttime && node->endtime > akttime)
345                {
346                        debug(1000, "out");
347                        m_unlock(&status.epgmutex, 4);
348                        return node;
349                }
350
351                node = node->next;
352        }
353
354        m_unlock(&status.epgmutex, 4);
355        return NULL;
356}
357
358struct epg* getepgnext(struct channel* chnode)
359{
360        debug(1000, "in");
361        time_t akttime = time(NULL);
362
363        m_lock(&status.epgmutex, 4);
364
365        if(chnode == NULL || chnode->epg == NULL)
366        {
367                debug(1000, "out-> NULL detect");
368                m_unlock(&status.epgmutex, 4);
369                return NULL;
370        }
371
372        struct epg *node = chnode->epg;
373
374        while(node != NULL)
375        {
376                if(node->starttime >= akttime)
377                {
378                        debug(1000, "out");
379                        m_unlock(&status.epgmutex, 4);
380                        return node;
381                }
382
383                node = node->next;
384        }
385
386        m_unlock(&status.epgmutex, 4);
387        return NULL;
388}
389
390struct epg* getepgakt(struct channel* chnode)
391{
392#ifdef SIMULATE
393        time_t akttime = 1307871000;
394        //akttime = 1315614900;
395        //akttime = 1317927300;
396        //akttime = 1307971000;
397#else
398        time_t akttime = time(NULL);
399#endif
400        return getepgbytime(chnode, akttime);
401}
402
403//flag 0: lock
404//flag 1: nolock
405struct epg* getepg(struct channel* chnode, int eventid, int flag)
406{
407        if(chnode == NULL)
408        {
409                debug(1000, "out-> NULL detect");
410                return NULL;
411        }
412
413        if(flag == 0) m_lock(&status.epgmutex, 4);
414
415        struct epg *node = chnode->epg;
416
417        while(node != NULL)
418        {
419                if(node->eventid == eventid)
420                {
421                        if(flag == 0) m_unlock(&status.epgmutex, 4);
422                        return node;
423                }
424
425                node = node->next;
426        }
427        if(flag == 0) m_unlock(&status.epgmutex, 4);
428        return NULL;
429}
430
431//flag 0: lock
432//flag 1: nolock
433struct epg* updateepg(struct channel* chnode, struct epg* epgnode, int eventid, int version, time_t starttime, time_t endtime, int flag)
434{
435//      debug(1000, "in");
436        int changetime = 0;
437
438        if(chnode == NULL || epgnode == NULL)
439        {
440                debug(1000, "out-> NULL detect");
441                return NULL;
442        }
443
444        //if(epgnode->version >= version) return epgnode;
445        if(endtime <= time(NULL)) return epgnode;
446
447        if(flag == 0) m_lock(&status.epgmutex, 4);
448
449        struct epg *prev = NULL, *node = chnode->epg;
450
451        epgnode->eventid = eventid;
452        epgnode->version = version;
453        if(epgnode->starttime != starttime)
454        {
455                changetime = 1;
456                epgnode->starttime = starttime;
457        }
458        epgnode->endtime = endtime;
459
460        if(changetime == 1)
461        {
462                if(chnode->epg == epgnode)
463                {
464                        chnode->epg = epgnode->next;
465                        node = chnode->epg;
466                }
467
468                if(epgnode->prev != NULL) epgnode->prev->next = epgnode->next;
469                if(epgnode->next != NULL) epgnode->next->prev = epgnode->prev;
470                epgnode->prev = NULL;
471                epgnode->next = NULL;
472
473                while(node != NULL && epgnode->starttime >= node->starttime)
474                {
475                        prev = node;
476                        node = node->next;
477                }
478
479                //check if new epg overlapps prev epg
480                if(prev != NULL && epgnode->starttime < prev->endtime)
481                {
482                        struct epg *tmp = prev->prev;
483                        addoldentryepg(chnode, prev, 1);
484                        prev = tmp;
485                }
486                //check if new epg overlaps next epg
487                while(node != NULL && epgnode->endtime > node->starttime)
488                {
489                        struct epg *tmp = node;
490                        node = node->next;
491                        addoldentryepg(chnode, tmp, 1);
492                }
493
494                if(prev == NULL)
495                        chnode->epg = epgnode;
496                else
497                {
498                        prev->next = epgnode;
499                        epgnode->prev = prev;
500                }
501                epgnode->next = node;
502                if(node != NULL) node->prev = epgnode;
503        }
504
505        if(flag == 0) m_unlock(&status.epgmutex, 4);
506//      debug(1000, "out");
507        return epgnode;
508}
509
510//flag 0: lock
511//flag 1: nolock
512struct epg* addoldentryepg(struct channel* chnode, struct epg* newnode, int flag)
513{
514//      debug(1000, "in");
515
516        if(newnode == NULL)
517        {
518                debug(1000, "out-> NULL detect");
519                return NULL;
520        }
521
522        if(flag == 0) m_lock(&status.epgmutex, 4);
523
524        clearepgentry(newnode);
525
526        if(newnode == chnode->epg)
527        {
528                chnode->epg = newnode->next;
529                if(chnode->epg != NULL)
530                        chnode->epg->prev = NULL;
531        }
532        else
533        {
534                if(newnode->prev != NULL)
535                {
536                        newnode->prev->next = newnode->next;
537                        if(newnode->next != NULL)
538                                newnode->next->prev = newnode->prev;
539                }
540        }
541
542        if(flag == 0) m_unlock(&status.epgmutex, 4);
543
544        addoldentry((void*)newnode, 0, time(NULL) + 3600, NULL);
545
546//      debug(1000, "out");
547        return newnode;
548}
549
550//flag 0: lock
551//flag 1: nolock
552struct epg* addepg(struct channel* chnode, int eventid, int version, time_t starttime, time_t endtime, struct epg* last, int flag)
553{
554//      debug(1000, "in");
555
556        if(chnode == NULL)
557        {
558                debug(1000, "out-> NULL detect");
559                return NULL;
560        }
561
562        if(flag == 0) m_lock(&status.epgmutex, 4);
563
564        struct epg *newnode = NULL, *prev = NULL, *node = chnode->epg;
565
566        newnode = (struct epg*)malloc(sizeof(struct epg));     
567        if(newnode == NULL)
568        {
569                err("no memory");
570                if(flag == 0) m_unlock(&status.epgmutex, 4);
571                return NULL;
572        }
573
574        memset(newnode, 0, sizeof(struct epg));
575
576        newnode->eventid = eventid;
577        newnode->version = version;
578        newnode->starttime = starttime;
579        newnode->endtime = endtime;
580
581        if(last == NULL)
582        {
583                while(node != NULL && newnode->starttime >= node->starttime)
584                {
585                        prev = node;
586                        node = node->next;
587                }
588        }
589        else
590        {
591                prev = last;
592                node = last->next;
593        }
594
595        //check if new epg overlaps next epg
596        while(node != NULL && newnode->endtime > node->starttime)
597        {
598                struct epg *tmp = node;
599                node = node->next;
600                addoldentryepg(chnode, tmp, 1);
601        }
602        //check if new epg overlapps prev epg
603        if(prev != NULL && newnode->starttime < prev->endtime)
604        {
605                clearepgentry(prev);
606                prev->eventid = eventid;
607                prev->version = version;
608                prev->starttime = starttime;
609                prev->endtime = endtime;
610                prev->parentalrating = 0;
611
612                free(newnode); newnode = NULL;
613                if(flag == 0) m_unlock(&status.epgmutex, 4);
614                return prev;
615        }
616
617        if(prev == NULL)
618                chnode->epg = newnode;
619        else
620        {
621                prev->next = newnode;
622                newnode->prev = prev;
623        }
624        newnode->next = node;
625        if(node != NULL) node->prev = newnode;
626
627        if(flag == 0) m_unlock(&status.epgmutex, 4);
628//      debug(1000, "out");
629        return newnode;
630}
631
632void deloldentryepg(struct epg* node)
633{
634        debug(1000, "in");
635
636        if(node == NULL)
637        {
638                debug(1000, "out-> NULL detect");
639                return;
640        }
641
642        clearepgentry(node);
643
644        free(node);
645        node = NULL;
646
647        debug(1000, "out");
648}
649
650void clearepgentry(struct epg* node)
651{
652        if(node == NULL) return;
653
654        free(node->title);
655        node->title = NULL;
656        free(node->subtitle);
657        node->subtitle = NULL;
658        free(node->desc);
659        node->desc = NULL;
660        node->desclen = 0;
661        node->desccomplen = 0;
662}
663
664//flag 0: lock
665//flag 1: nolock
666void delepg(struct channel* chnode, struct epg* epgnode, int flag)
667{
668        debug(1000, "in");
669
670        if(chnode == NULL)
671        {
672                debug(1000, "out-> NULL detect");
673                return;
674        }
675
676        if(flag == 0) m_lock(&status.epgmutex, 4);
677
678        struct epg *node = chnode->epg, *prev = chnode->epg;
679
680        while(node != NULL)
681        {
682                if(node == epgnode)
683                {
684                        if(node == chnode->epg)
685                        {
686                                chnode->epg = node->next;
687                                if(chnode->epg != NULL)
688                                        chnode->epg->prev = NULL;
689                        }
690                        else
691                        {
692                                prev->next = node->next;
693                                if(prev->next != NULL)
694                                        prev->next->prev = prev;
695                        }
696
697                        clearepgentry(node);
698
699                        free(node);
700                        node = NULL;
701                        break;
702                }
703
704                prev = node;
705                node = node->next;
706        }
707        if(flag == 0) m_unlock(&status.epgmutex, 4);
708        debug(1000, "out");
709}
710
711void freeepg(struct channel* chnode)
712{
713        debug(1000, "in");
714
715        if(chnode == NULL)
716        {
717                debug(1000, "out-> NULL detect");
718                return;
719        }
720
721        m_lock(&status.epgmutex, 4);
722        struct epg *node = chnode->epg, *prev = chnode->epg;
723
724        while(node != NULL)
725        {
726                prev = node;
727                node = node->next;
728                if(prev != NULL)
729                        delepg(chnode, prev, 1);
730        }
731        m_unlock(&status.epgmutex, 4);
732        debug(1000, "out");
733}
734
735//flag 0: stop scanlist and delete epg.dat
736//flag 1: don't stop scanlist, don't delete epg.dat
737void resetepg(int flag)
738{
739        struct channel *node = channel;
740        char* tmpstr = NULL;
741
742        //stop epgscanlistthread
743        if(flag == 0 && status.epgscanlistthread != NULL)
744                status.epgscanlistthread->aktion = STOP;
745
746        if(status.epgthread != NULL)
747                status.epgthread->aktion = PAUSE;
748
749        //wait a little for thread end/pause
750        sleep(1);
751
752        while(node != NULL)
753        {
754                freeepg(node);
755                node = node->next;
756        }
757
758        if(flag == 0)
759        {
760                tmpstr = createpath(getconfig("epg_path", NULL), "epg.dat");
761                unlink(tmpstr);
762                free(tmpstr); tmpstr = NULL;
763        }
764
765        //set lastepg to 0 so, epg is running
766        deltransponderlastepg();
767
768        if(status.epgthread != NULL)
769                status.epgthread->aktion = START;
770}
771
772void deloldepg()
773{
774        struct channel* chnode = channel;
775        struct epg* epgnode = NULL;
776
777        m_lock(&status.epgmutex, 4);
778        while(chnode != NULL)
779        {
780                if(chnode->epg != NULL)
781                {
782                        epgnode = channel->epg;
783                        while(epgnode != NULL)
784                        {
785                                if(epgnode->endtime + 60 < time(NULL))
786                                        delepg(chnode, epgnode, 1);
787                                epgnode = epgnode->next;
788                        }
789                }
790                chnode = chnode->next;
791        }
792        m_unlock(&status.epgmutex, 4);
793
794        deloldlinkedchannel();
795}
796
797/*
798//Parse language-id translation file
799char *eitlang(u_char *l)
800{
801        static union lookup_key lang;
802        lang.c[0] = (char)l[0];
803        lang.c[1] = (char)l[1];
804        lang.c[2] = (char)l[2];
805        lang.c[3] = '\0';
806
807        char *c = lookup(languageid_table, lang.i);
808        return c ? c : lang.c;
809}
810*/
811
812//Parse 0x4D Short Event Descriptor
813void eventdesc(struct channel* chnode, struct epg* epgnode, void *buf)
814{
815        struct transponder* tpnode = NULL;
816        struct eitshortevent *evtdesc = buf;
817        char* title = NULL, *subtitle = NULL;
818        int evtlen = evtdesc->event_name_length;
819        int dsclen = 0;
820
821        if(!evtlen) return;
822        if(chnode != NULL) tpnode = chnode->transponder;
823
824        //title
825        title = malloc(evtlen + 1);
826        if(title == NULL)
827        {
828                err("no mem");
829                return;
830        }
831        memcpy(title, (char *)&evtdesc->data, evtlen);
832        title[evtlen] = '\0';
833        free(epgnode->title);
834        epgnode->title = strutf8(tpnode, title, evtlen, 0, 1, 0);
835
836        //subtitle
837        dsclen = evtdesc->data[evtlen];
838        subtitle = malloc(dsclen + 1);
839        if(subtitle == NULL)
840        {
841                err("no mem");
842                return;
843        }
844        memcpy(subtitle, (char *)&evtdesc->data[evtlen + 1], dsclen);
845        subtitle[dsclen] = '\0';
846        free(epgnode->subtitle);
847        epgnode->subtitle = strutf8(tpnode, subtitle, dsclen, 0, 1, 0);
848}
849
850void epgadddesc(struct epg* epgnode, char* desc)
851{
852        int len = 0;
853       
854        if(desc != NULL) len = strlen(desc);
855        epgnode->desclen += len;
856
857        epgnode->desc = realloc(epgnode->desc, epgnode->desclen + 1);
858        if(epgnode->desc == NULL)
859        {
860                err("no mem");
861                epgnode->desclen = 0;
862                return;
863        }
864        memcpy(epgnode->desc + epgnode->desclen - len, desc, len + 1);
865}
866
867// Parse 0x4E Extended Event Descriptor
868void longeventdesc(struct channel* chnode, struct epg* epgnode, unsigned char *buf)
869{
870        struct transponder* tpnode = NULL;
871        struct eitlongevent *levt = (struct eitlongevent*)buf;
872        char* desc = NULL;
873
874        if(chnode != NULL) tpnode = chnode->transponder;
875        int nonempty = (levt->descriptor_number || levt->last_descriptor_number || levt->length_of_items || levt->data[0]);
876
877        void *p = &levt->data;
878        while(p < (void *)levt->data + levt->length_of_items)
879        {
880                struct eitlongeventitem *name = p;
881                int namelen = name->item_description_length;
882                desc = malloc(namelen + 1);
883                if(desc == NULL)
884                {
885                        err("no mem");
886                        return;
887                }
888                memcpy(desc, (char *)&name->data, namelen);
889                desc[namelen] = '\0';
890                desc = strutf8(tpnode, desc, namelen, 0, 1, 0);
891                epgadddesc(epgnode, desc);
892                free(desc); desc = NULL;
893                p += EITLONGEVENTITEMLEN + namelen;
894
895                struct eitlongeventitem *value = p;
896                int valuelen = value->item_description_length;
897                desc = malloc(valuelen + 1);
898                if(desc == NULL)
899                {
900                        err("no mem");
901                        return;
902                }
903                memcpy(desc, (char *)&value->data, valuelen);
904                desc[valuelen] = '\0';
905                desc = strutf8(tpnode, desc, valuelen, 0, 1, 0);
906                epgadddesc(epgnode, desc);
907                free(desc); desc = NULL;
908                p += EITLONGEVENTITEMLEN + valuelen;
909        }
910
911        struct eitlongeventitem *text = p;
912        int textlen = text->item_description_length;
913        if(nonempty && textlen)
914        {
915                desc = malloc(textlen + 1);
916                if(desc == NULL)
917                {
918                        err("no mem");
919                        return;
920                }
921                memcpy(desc, (char *)&text->data, textlen);
922                desc[textlen] = '\0';
923                desc = strutf8(tpnode, desc, textlen, 0, 1, 0);
924                epgadddesc(epgnode, desc);
925                free(desc); desc = NULL;
926        }
927
928        free(desc); desc = NULL;
929}
930
931// Parse 0x55 Rating Descriptor
932void ratingdescr(struct epg* epgnode, unsigned char *buf)
933{
934        struct parentalrating *pr = (struct parentalrating*)buf;
935        void *p = NULL;
936
937        for(p = &pr->data; p < (void*)buf + pr->descriptor_length; p += PARENTALRATINGITEMLEN)
938        {
939                struct parentalratingitem *pr = p;
940                switch(pr->rating)
941                {
942                        case 0x00: //undefined
943                                break;
944                        case 0x01 ... 0x0F:
945                                epgnode->parentalrating = pr->rating + 3;
946                                break;
947                        case 0x10 ... 0xFF: //broadcaster defined
948                                break;
949                }
950        }
951}
952
953// Parse 0x4A Linkage Descriptor
954void linkagedesc(struct channel* chnode, struct epg* epgnode, void *buf)
955{
956        struct eitlinkage *evtlink = buf;
957        uint64_t transponderid = 0;
958       
959        int tid = HILO(evtlink->transport_stream_id);
960        int onid = HILO(evtlink->original_network_id);
961        int serviceid = HILO(evtlink->service_id);
962       
963        transponderid = ((onid << 16) | tid) & 0xffffffff;
964
965        if(chnode != NULL && chnode->transponder != NULL)
966        {
967                if(chnode->transponder->fetype == FE_QAM)
968                        transponderid = transponderid | ((uint64_t)1 << 32);
969                else if(chnode->transponder->fetype == FE_OFDM)
970                        transponderid = transponderid | ((uint64_t)2 << 32);
971
972                if(getlinkedchannel(chnode, serviceid, transponderid, epgnode->starttime, epgnode->endtime) == NULL)
973                        addlinkedchannel(chnode, serviceid, transponderid, epgnode->starttime, epgnode->endtime, NULL);
974        }
975}
976
977#if 0
978// Parse 0x50 Component Descriptor
979void componentdescr(struct epg* epgnode, unsigned char *buf)
980{
981        struct eitcomponent *dc = buf;
982
983        switch(dc->stream_content)
984        {
985                case 0x01: // Video Info
986                        //if ((dc->component_type - 1) & 0x08) //HD TV
987                        //if ((dc->component_type - 1) & 0x04) //30Hz else 25
988                        printf("aspect %s\n", lookup(aspect_table, (dc->component_type - 1) & 0x03));
989                        break;
990                case 0x02: // Audio Info
991                        printf("stereo %s\n", lookup(audio_table, (dc->component_type)));
992                        printf("language %d\n", dc->lang_code1);
993                        break;
994                case 0x03: // Teletext Info
995                        // if ((dc->component_type) & 0x10) //subtitles
996                        // if ((dc->component_type) & 0x20) //subtitles for hard of hearing
997                        printf("txt language %d\n", dc->lang_code1);
998                        break;
999                // case 0x04: // AC3 info
1000        }
1001#if 0
1002        printf("StreamContent %d\n", dc->stream_content);
1003        printf("ComponentType %x\n", dc->component_type);
1004        printf("ComponentTag %x\n", dc->component_tag);
1005        printf("Length %d\n", dc->descriptor_length - 6);
1006#endif
1007}
1008
1009inline void eitsetbit(int *bf, int b)
1010{
1011        int i = b / 8 / sizeof(int);
1012        int s = b % (8 * sizeof(int));
1013        bf[i] |= (1 << s);
1014}
1015
1016inline bool eitgetbit(int *bf, int b)
1017{
1018        int i = b / 8 / sizeof(int);
1019        int s = b % (8 * sizeof(int));
1020        return bf[i] & (1 << s);
1021}
1022
1023// Parse 0x54 Content Descriptor
1024void contentdescr(struct epg* epgnode, unsigned char *buf)
1025{
1026        struct eitcontent *dc = buf;
1027
1028        int once[256/8/sizeof(int)] = {0,};
1029        void *p;
1030        for(p = &dc->data; p < data + dc->descriptor_length; p += NIBBLE_CONTENT_LEN)
1031        {
1032                struct nibble_content *nc = p;
1033                int c1 = (nc->content_nibble_level_1 << 4) + nc->content_nibble_level_2;
1034#ifdef CATEGORY_UNKNOWN
1035                int c2 = (nc->user_nibble_1 << 4) + nc->user_nibble_2;
1036#endif
1037                if(c1 > 0 && !eitgetbit(once, c1))
1038                {
1039                        eitsetbit(once, c1);
1040                        char *c = lookup(description_table, c1);
1041                        if(c)
1042                                if(c[0])
1043                                        printf("\t<category>%s</category>\n", c);
1044#ifdef CATEGORY_UNKNOWN
1045                                else
1046                                        printf("\t<!--category>%s %02X %02X</category-->\n", c+1, c1, c2);
1047                        else
1048                                printf("\t<!--category>%02X %02X</category-->\n", c1, c2);
1049#endif
1050                }
1051                // This is weird in the uk, they use user but not content, and almost the same values
1052        }
1053}
1054
1055// Parse 0x5F Private Data Specifier
1056int privatedataspecifier(struct epg* epgnode, unsigned char *buf)
1057{
1058        return GetPrivateDataSpecifier(data);
1059}
1060
1061// Parse 0x76 Content Identifier Descriptor
1062void contentidentifierdesc(struct epg* epgnode, unsigned char *buf)
1063{
1064        struct descr_content_identifier *ci = data;
1065        void *p;
1066        for(p = &ci->data; p < data + ci->descriptor_length; /* at end */)
1067        {
1068                struct descr_content_identifier_crid *crid = p;
1069                struct descr_content_identifier_crid_local *crid_data;
1070
1071                int crid_length = 3;
1072
1073                char type_buf[32];
1074                char *type;
1075                char buf[256];
1076
1077                type = lookup(crid_type_table, crid->crid_type);
1078                if(type == NULL)
1079                {
1080                        type = type_buf;
1081                        sprintf(type_buf, "0x%2x", crid->crid_type);
1082                }
1083
1084                switch(crid->crid_location)
1085                {
1086                        case 0x00: /* Carried explicitly within descriptor */
1087                                crid_data = (descr_content_identifier_crid_local_t *)&crid->crid_ref_data;
1088                                int cridlen = crid_data->crid_length;
1089                                assert(cridlen < sizeof(buf));
1090                                memcpy(buf, (char *)&crid_data->crid_byte, cridlen);
1091                                buf[cridlen] = '\0';
1092
1093                                printf("\t<crid type='%s'>%s</crid>\n", type, xmlify(buf));
1094                                crid_length = 2 + crid_data->crid_length;
1095                                break;
1096                        case 0x01: /* Carried in Content Identifier Table (CIT) */
1097                                break;
1098                        default:
1099                                break;
1100                }
1101                p += crid_length;
1102        }
1103}
1104#endif
1105
1106//Parse Descriptor
1107void parseeitdesc(struct channel* chnode, struct epg* epgnode, unsigned char *buf, int len, int nolongdesc)
1108{
1109        unsigned char *p;
1110        for(p = buf; p < buf + len; p += 2 + p[1])
1111        {
1112                switch((int)p[0])
1113                {
1114                        case 0:
1115                                break;
1116                        case 0x4A:
1117                                linkagedesc(chnode, epgnode, p);
1118                                break;
1119                        case 0x4D:
1120                                eventdesc(chnode, epgnode, p);
1121                                break;
1122                        case 0x4E:
1123                                if(nolongdesc == 0)
1124                                        longeventdesc(chnode, epgnode, p);
1125                                break;
1126                        case 0x55:
1127                                ratingdescr(epgnode, p);
1128                                break;
1129/*
1130                        case 0x50:
1131                                componentdescr(epgnode, p, LANGUAGE);
1132                                componentdescr(epgnode, p, VIDEO);
1133                                componentdescr(epgnode, p, AUDIO);
1134                                componentdescr(epgnode, p, SUBTITLES);
1135                                break;
1136                        case 0x53: // CA Identifier Descriptor
1137                                break;
1138                        case 0x54:
1139                                contentdescr(epgnode, p);
1140                                break;
1141                        case 0x5f: // Private Data Specifier
1142                                pds = privatedataspecifier(epgnode, p);
1143                                break;
1144                        case 0x64: // Data broadcast desc - Text Desc for Data components
1145                                break;
1146                        case 0x69: // Programm Identification Label
1147                                break;
1148                        case 0x81: // TODO ???
1149                                if(pds == 5) // ARD_ZDF_ORF
1150                                        break;
1151                        case 0x82: // VPS (ARD, ZDF, ORF)
1152                                if(pds == 5) // ARD_ZDF_ORF
1153                                        // TODO: <programme @vps-start="???">
1154                                        break;
1155                        case 0x4F: // Time Shifted Event
1156                        case 0x52: // Stream Identifier Descriptor
1157                        case 0x5E: // Multi Lingual Component Descriptor
1158                        case 0x83: // Logical Channel Descriptor (some kind of news-ticker on ARD-MHP-Data?)
1159                        case 0x84: // Preferred Name List Descriptor
1160                        case 0x85: // Preferred Name Identifier Descriptor
1161                        case 0x86: // Eacem Stream Identifier Descriptor
1162                                break;
1163                        case 0x76:
1164                                contentidentifierdesc(epgnode, p);
1165                                break;
1166*/
1167                }
1168        }
1169}
1170
1171// Parse Event Information Table
1172//flag 0 = from epg thread
1173//flag 1 = from epg scan
1174void parseeit(struct channel* chnode, unsigned char *buf, int len, int flag)
1175{
1176        struct eit* eit = (struct eit*)buf;
1177        unsigned char *p;
1178        time_t dvbtime = 0, starttime = 0, endtime = 0;
1179        struct channel* tmpchnode = NULL;
1180        struct epg* epgnode = NULL;
1181        char* zbuf = NULL;
1182        int zlen = 0, ret = 0, eitlen = 0;
1183        time_t epgmaxsec = status.epgdays * 24 * 60 * 60;
1184        uint64_t transponderid = 0;
1185        int serviceid = 0, eventid = 0;
1186        int nolongdesc = 0;
1187
1188        len -= 4; //remove CRC
1189        if(chnode == NULL) chnode = status.aktservice->channel;
1190
1191        // For each event listing
1192        for (p = (unsigned char*)&eit->data; p < buf + len; p += EITEVENTLEN + GETEITDESCLEN(p))
1193        {
1194                nolongdesc = 0;
1195                struct eitevent* evt = (struct eitevent*)p;
1196
1197                // No program info at end! Just skip it
1198                eitlen = GETEITDESCLEN(evt);
1199                if(eitlen == 0 || chnode == NULL)
1200                        return;
1201                if(flag == 0 && chnode == status.aktservice->channel && status.aktservice->type != CHANNEL)
1202                        return;
1203               
1204                transponderid = ((HILO(eit->original_network_id) << 16) | HILO(eit->transport_stream_id)) & 0xffffffff;
1205                if(chnode->transponder != NULL)
1206                {
1207                        if(chnode->transponder->fetype == FE_QAM)
1208                                transponderid = transponderid | ((uint64_t)1 << 32);
1209                        else if(chnode->transponder->fetype == FE_OFDM)
1210                                transponderid = transponderid | ((uint64_t)2 << 32);
1211                }
1212
1213                serviceid = HILO(eit->service_id);
1214                tmpchnode = getchannel(serviceid, transponderid);
1215                if(tmpchnode == NULL)
1216                {
1217                        debug(1000, "out -> NULL detect");
1218                        continue;
1219                }
1220
1221                //look in epglist if channel exists
1222                //only if epglist is marked as whitelist
1223                if(status.epglistmode == 2 || status.epglistmode == 3)
1224                {
1225                        if(getepgscanlist(serviceid, transponderid) == NULL)
1226                                continue;
1227                }
1228
1229                m_lock(&status.epgmutex, 4);
1230                eventid = HILO(evt->event_id);
1231                epgnode = getepg(tmpchnode, eventid, 1);
1232
1233                dvbtime = dvbconvertdate(&evt->mjd_hi, 0);
1234                starttime = dvbtime;
1235                starttime -= starttime % 60;
1236
1237                dvbtime += bcdtoint(evt->duration_s & 0xff);
1238                dvbtime += (bcdtoint(evt->duration_m & 0xff) * 60);
1239                dvbtime += (bcdtoint(evt->duration_h & 0xff) * 60 * 60);
1240                endtime = dvbtime;
1241                endtime -= endtime % 60;
1242
1243#ifndef SIMULATE
1244                if(endtime < time(NULL) || starttime > time(NULL) + epgmaxsec)
1245                {
1246                        m_unlock(&status.epgmutex, 4);
1247                        continue;
1248                }
1249#endif
1250
1251                if(epgnode == NULL)
1252                                epgnode = addepg(tmpchnode, eventid, eit->version_number, starttime, endtime, NULL, 1);
1253                else
1254                {
1255                        updateepg(tmpchnode, epgnode, eventid, eit->version_number, starttime, endtime, 1);
1256                        if(epgnode->desc != NULL)
1257                                nolongdesc = 1;
1258                }
1259
1260                if(epgnode == NULL)
1261                {
1262                        debug(1000, "out -> NULL detect");
1263                        m_unlock(&status.epgmutex, 4);
1264                        continue;
1265                }
1266
1267                //1 Airing, 2 Starts in a few seconds, 3 Pausing, 4 About to air
1268                //printf("RunningStatus %d\n", evt->running_status);
1269
1270                parseeitdesc(tmpchnode, epgnode, (unsigned char*)&evt->data, eitlen, nolongdesc);
1271                //compress long desc
1272                if(nolongdesc == 0 && epgnode->desc != NULL)
1273                {
1274                        ret = ozip(epgnode->desc, strlen(epgnode->desc) + 1, &zbuf, &zlen, 1);
1275                        if(ret == 0)
1276                        {
1277                                free(epgnode->desc); epgnode->desc = NULL;
1278                                epgnode->desc = zbuf;
1279                                epgnode->desccomplen = zlen;
1280                        }
1281                }
1282                m_unlock(&status.epgmutex, 4);
1283        }
1284}
1285
1286int readepg(const char* filename)
1287{
1288        debug(1000, "in");
1289        FILE *fd = NULL;
1290        struct channel *chnode = channel, *oldchnode = NULL;
1291        struct epg* epgnode = NULL;
1292        int ret = 0, len = 0, count = 0;
1293        time_t epgmaxsec = status.epgdays * 24 * 60 * 60;
1294
1295        fd = fopen(filename, "rb");
1296        if(fd == NULL)
1297        {
1298                perr("can't open %s", filename);
1299                return 1;
1300        }
1301       
1302        m_lock(&status.epgmutex, 4);
1303
1304        while(!feof(fd))
1305        {
1306                int serviceid = 0, eventid = 0, version = 0;
1307                uint64_t transponderid = 0;
1308                time_t starttime = 0, endtime = 0;
1309                int desclen = 0, desccomplen = 0, parentalrating = 0;
1310                char* title = NULL, *subtitle = NULL, *desc = NULL;
1311
1312                ret = fread(&serviceid, sizeof(int), 1, fd);
1313                if(feof(fd)) break;
1314                ret = fread(&transponderid, sizeof(uint64_t), 1, fd);
1315                ret = fread(&eventid, sizeof(int), 1, fd);
1316                ret = fread(&version, sizeof(int), 1, fd);
1317                ret = fread(&parentalrating, sizeof(int), 1, fd);
1318                ret = fread(&starttime, sizeof(time_t), 1, fd);
1319                ret = fread(&endtime, sizeof(time_t), 1, fd);
1320
1321                //if epg.dat has an IO Error it runs in endless loop
1322                //this stops the endless loop
1323                if(starttime == 0 && endtime == 0)
1324                        count++;
1325                else
1326                        count = 0;
1327                if(count > 50) break;
1328
1329                len = 0;
1330                ret = fread(&len, sizeof(int), 1, fd);
1331                if(len > 0 && len <= 4096)
1332                {
1333                        title = malloc(len + 1);
1334                        if(title == NULL)
1335                        {
1336                                err("title no mem %d", len);
1337                                free(title); title = NULL;
1338                                free(subtitle); subtitle = NULL;
1339                                free(desc); desc = NULL;
1340                                break;
1341                        }
1342                        ret = fread(title, len, 1, fd);
1343                        title[len] = '\0';
1344                }
1345                else if(len != 0)
1346                {
1347                        err("epgfile defekt title len=%d", len);
1348                        free(title); title = NULL;
1349                        free(subtitle); subtitle = NULL;
1350                        free(desc); desc = NULL;
1351                        break;
1352                }
1353       
1354                len = 0;
1355                ret = fread(&len, sizeof(int), 1, fd);
1356                if(len > 0 && len <= 4096)
1357                {
1358                        subtitle = malloc(len + 1);
1359                        if(subtitle == NULL)   
1360                        {
1361                                err("subtitle no mem %d", len);
1362                                free(title); title = NULL;
1363                                free(subtitle); subtitle = NULL;
1364                                free(desc); desc = NULL;
1365                                break;
1366                        }
1367                        ret = fread(subtitle, len, 1, fd);
1368                        subtitle[len] = '\0';
1369                }
1370                else if(len != 0)
1371                {
1372                        err("epgfile defekt subtitle len=%d", len);
1373                        free(title); title = NULL;
1374                        free(subtitle); subtitle = NULL;
1375                        free(desc); desc = NULL;
1376                        break;
1377                }
1378
1379                ret = fread(&desclen, sizeof(int), 1, fd);
1380                ret = fread(&desccomplen, sizeof(int), 1, fd);
1381       
1382                len = desccomplen;
1383                if(len == 0)
1384                        len = desclen;
1385                if(len > 0 && len <= 4096)
1386                {
1387                        if(desccomplen == 0)
1388                                desc = malloc(len + 1);
1389                        else
1390                                desc = malloc(len);
1391                        if(desc == NULL)
1392                        {
1393                                err("desc no mem %d", len);
1394                                free(title); title = NULL;
1395                                free(subtitle); subtitle = NULL;
1396                                free(desc); desc = NULL;
1397                                break;
1398                        }
1399                        ret = fread(desc, len, 1, fd);
1400                        if(desccomplen == 0)
1401                                desc[len] = '\0';
1402                }
1403                else if(len != 0)
1404                {
1405                        err("epgfile defekt desc len=%d", len);
1406                        free(title); title = NULL;
1407                        free(subtitle); subtitle = NULL;
1408                        free(desc); desc = NULL;
1409                        break;
1410                }
1411
1412                if(oldchnode != NULL && oldchnode->serviceid == serviceid && oldchnode->transponderid == transponderid)
1413                        chnode = oldchnode;
1414                else
1415                {
1416                        chnode = getchannel(serviceid, transponderid);
1417                        if(chnode == NULL)
1418                        {
1419                                debug(1000, "out -> NULL detect");
1420                                free(title); title = NULL;
1421                                free(subtitle); subtitle = NULL;
1422                                free(desc); desc = NULL;
1423                                continue;
1424                        }
1425                        oldchnode = chnode;
1426                        epgnode = NULL;
1427                }
1428
1429#ifndef SIMULATE
1430                if(endtime < time(NULL) || starttime > time(NULL) + epgmaxsec)
1431                {
1432                        free(title); title = NULL;
1433                        free(subtitle); subtitle = NULL;
1434                        free(desc); desc = NULL;
1435                        continue;
1436                }
1437#endif
1438
1439                epgnode = addepg(chnode, eventid, version, starttime, endtime, epgnode, 1);
1440                if(epgnode == NULL)
1441                {
1442                        debug(1000, "out -> NULL detect");
1443                        free(title); title = NULL;
1444                        free(subtitle); subtitle = NULL;
1445                        free(desc); desc = NULL;
1446                        continue;
1447                }
1448                epgnode->parentalrating = parentalrating;
1449                epgnode->desclen = desclen;
1450                epgnode->desccomplen = desccomplen;
1451                epgnode->title = title;
1452                epgnode->subtitle = subtitle;
1453                epgnode->desc = desc;
1454        }
1455
1456        fclose(fd);
1457
1458        if(getconfigint("epg_del", NULL) == 1)
1459                unlink(filename);
1460               
1461        m_unlock(&status.epgmutex, 4);
1462
1463        //epg.dat seems defekt IO Error
1464        if(count > 50) unlink(filename);
1465
1466        debug(1000, "out");
1467        return 0;
1468}
1469
1470//Read EIT segments from DVB-demuxer
1471//flag 0 = from epg thread
1472//flag 1 = from epg scan
1473int readeit(struct stimerthread* self, struct channel* chnode, struct dvbdev* fenode, int flag)
1474{
1475        int readlen = 0, pos = 0, len = 0;
1476        unsigned char *buf = NULL, *head = NULL;
1477        struct dvbdev* dmxnode;
1478        struct eit* eit = NULL;
1479        unsigned long seen[16] = {0};
1480        unsigned long firstseen[16] = {0};
1481        int roundend = 0, round = 0x4e, i = 0;
1482        time_t akttime, roundstart;
1483
1484        if(chnode == NULL) chnode = status.aktservice->channel;
1485
1486        buf = malloc(MINMALLOC * 4);
1487        if(buf == NULL)
1488        {
1489                err("no memory");
1490                return 1;
1491        }
1492        head = buf;
1493
1494        if(fenode == NULL) fenode = status.aktservice->fedev;
1495        if(fenode == NULL)
1496        {
1497                debug(400, "no frontend dev in service");
1498                free(buf);
1499                return 1;
1500        }
1501
1502        dmxnode = dmxopen(fenode);
1503        if(dmxnode == NULL)
1504        {
1505                err("open demux dev");
1506                free(buf);
1507                return 1;
1508        }
1509
1510        dmxsetbuffersize(dmxnode, getconfigint("dmxepgbuffersize", NULL));
1511        dmxsetsource(dmxnode, fenode->fedmxsource);
1512
1513#ifdef SIMULATE
1514        int fd = open("simulate/epg.ts", O_RDONLY);
1515        if(fd == -1)
1516        {
1517                perr("open simulate/epg.ts");
1518                return 1;
1519        }
1520#endif
1521
1522        for(i = 2; i < 16; i++) firstseen[i] = 1;
1523        roundstart = time(NULL);
1524        dmxsetfilter(dmxnode, 0x12, 0, 8);
1525        while(self->aktion != STOP && self->aktion != PAUSE)
1526        {
1527                akttime = time(NULL);
1528                roundend = 1;
1529
1530                //check end of epg infos
1531                for(i = 0; i < 16; i++)
1532                {
1533                        if(roundstart + 5 < akttime && firstseen[i] == 0)
1534                                firstseen[i] = 1;
1535                        if(roundstart + 30 < akttime && firstseen[i] != 1)
1536                                firstseen[i] = 1;
1537                        if(firstseen[i] != 1)
1538                        {
1539                                roundend = 0;
1540                                break;
1541                        }
1542                }
1543               
1544                if(roundend == 1)
1545                {
1546                        for(i = 0; i < 16; i++)
1547                        {
1548                                seen[i] = 0;
1549                                firstseen[i] = 0;
1550                        }
1551
1552                        roundend = 0;
1553                        pos = 0;
1554                        head = buf;
1555
1556                        if(round == 0x60)
1557                        {
1558                                dmxstop(dmxnode);
1559                                debug(400, "epg no more new data, wait for next run");
1560
1561                                if(chnode != NULL && chnode->transponder != NULL)
1562                                        chnode->transponder->lastepg = time(NULL) + 7700;
1563
1564                                goto end;
1565                        }
1566                        if(round == 0x4e)
1567                        {
1568                                dmxsetfilter(dmxnode, 0x12, 0, 6);
1569                                round = 0x50;
1570                        }
1571                        else if(round == 0x50)
1572                        {
1573                                dmxsetfilter(dmxnode, 0x12, 0, 7);
1574                                round = 0x60;
1575                        }
1576                        else if(round == 0x60)
1577                        {
1578                                dmxsetfilter(dmxnode, 0x12, 0, 8);
1579                                for(i = 2; i < 16; i++) firstseen[i] = 1;
1580                                round = 0x4e;
1581                        }
1582                        roundstart = time(NULL);
1583                        continue;
1584                }
1585       
1586                if(pos < 3) goto read_more;
1587
1588                eit = (struct eit*)head;
1589
1590                len = 3 + GETEITSECLEN(eit);
1591                if(pos < len) goto read_more;
1592               
1593                if(eit->table_id - round < 0 || eit->table_id - round > 15 || dvbcrc32((uint8_t *)head, len) != 0)
1594                {
1595                        err("epg crc or table id not ok");
1596                        dmxstop(dmxnode);
1597                        dmxstart(dmxnode);
1598                        pos = 0;
1599                        head = buf;
1600                        goto read_more;
1601                }
1602
1603                seen[eit->table_id - round] = (eit->table_id << 24) | (HILO(eit->service_id) << 8) | eit->section_number;
1604
1605                if(firstseen[eit->table_id - round] == 0)
1606                        firstseen[eit->table_id - round] = seen[eit->table_id - round];
1607                else if(firstseen[eit->table_id - round] == seen[eit->table_id - round])
1608                        firstseen[eit->table_id - round] = 1;
1609
1610                parseeit(chnode, head, len, flag);
1611
1612                //remove packet
1613                pos -= len;
1614                head += len;
1615                continue;
1616read_more:
1617                //clear buffer
1618                if(pos == MINMALLOC * 4)
1619                {
1620                        pos = 0;
1621                        head = buf;
1622                        dmxstop(dmxnode);
1623                        dmxstart(dmxnode);
1624                }
1625
1626                //move remaining data to front of buffer
1627                if (pos > 0) memmove(buf, head, pos);
1628
1629                //fill with fresh data
1630#ifdef SIMULATE
1631                readlen = TEMP_FAILURE_RETRY(read(fd, buf + pos, (MINMALLOC * 4) - pos));
1632                usleep(200000);
1633#else
1634                readlen = dvbread(dmxnode, buf, pos, (MINMALLOC * 4) - pos, 500000);
1635                usleep(1000);
1636#endif
1637                if(readlen < 0) readlen = 0;
1638                head = buf;
1639                pos += readlen;
1640        }
1641
1642end:
1643#ifdef SIMULATE
1644        close(fd);
1645#endif
1646        dmxclose(dmxnode, -1);
1647        free(buf);
1648        return 0;
1649}
1650
1651void epgthreadfunc(struct stimerthread* self)
1652{
1653        debug(1000, "in");
1654        char* tmpstr = NULL;
1655        time_t akttime = 0;
1656        struct channel* chnode = NULL;
1657        int skip = 0, count = 0;
1658
1659        if(self == NULL) return;
1660
1661        //wait for right time
1662        while(self->aktion != STOP && time(NULL) < 1072224000) // 01.01.2004
1663                usleep(1 * 1000000);
1664
1665        debug(400, "start epg thread on aktiv channel");
1666
1667        if(self->notfirst == 0)
1668        {
1669                debug(400, "read epg data from file");
1670                status.deloldepg = time(NULL);
1671                status.writeperiodicepg = time(NULL);
1672                tmpstr = createpath(getconfig("epg_path", NULL), "epg.dat");
1673                readepg(tmpstr);
1674                free(tmpstr); tmpstr = NULL;
1675        }
1676
1677        if(status.epgscanlistthread == NULL)
1678        {
1679                akttime = time(NULL);
1680                chnode = status.aktservice->channel;
1681
1682                //del old epg date
1683                if(status.deloldepg + (5 * 60 * 60) < time(NULL)) // 5 stunde
1684                {
1685                        status.deloldepg = time(NULL);
1686                        deloldepg();
1687                }
1688
1689                //write epg periodic to medium
1690                if(status.writeperiodicepg + (2 * 60 * 60) < time(NULL)) // 2 stunde
1691                {
1692                        status.writeperiodicepg = time(NULL);
1693                        if(getconfigint("epgsave", NULL) == 0) //only write periodic if epgsave = allways
1694                                writeallconfig(2);
1695                }
1696
1697                if(chnode != NULL && chnode->transponder != NULL && chnode->transponder->lastepg > akttime && chnode->epg != NULL)
1698                {
1699                        debug(400, "skip epg read (%ld < %ld)", akttime, chnode->transponder->lastepg);
1700                        skip = (chnode->transponder->lastepg - akttime) * 2;
1701                }
1702
1703                if(skip > 0)
1704                {
1705                        while(self->aktion != STOP && self->aktion != PAUSE)
1706                        {
1707                                if(count > skip) break;
1708                                count++;
1709                                usleep(500000);
1710                        }
1711                        if(self->aktion == STOP || self->aktion == PAUSE) goto end;
1712                        count = 0;
1713                }
1714
1715                if(self->aktion != STOP && self->aktion != PAUSE)
1716                        readeit(self, NULL, NULL, 0);
1717                if(self->aktion != STOP && self->aktion != PAUSE)
1718                {
1719                        if(getconfigint("mhwepg", NULL) == 2)
1720                                readmhw(self, NULL, NULL, 0);
1721                }
1722                if(self->aktion != STOP && self->aktion != PAUSE)
1723                {
1724                        if(getconfigint("mhw2epg", NULL) == 2)
1725                                readmhw2(self, NULL, NULL, 0);
1726                }
1727                if(self->aktion != STOP && self->aktion != PAUSE)
1728                {
1729                        if(getconfigint("opentv", NULL) == 2)
1730                                readopentv(self, NULL, NULL, 0);
1731                }
1732
1733                //wait for next run
1734                while(self->aktion != STOP && self->aktion != PAUSE)
1735                {
1736                        if(count > 14400) break; //2h
1737                        count++;
1738                        usleep(500000);
1739                }
1740        }
1741
1742end:
1743        debug(400, "end epg thread on aktiv channel");
1744        debug(1000, "out");
1745}
1746
1747#endif
Note: See TracBrowser for help on using the repository browser.