source: titan/titan/eit.h @ 39538

Last change on this file since 39538 was 36344, checked in by obi, 8 years ago

reset

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