source: titan/titan/scan.h @ 24042

Last change on this file since 24042 was 24042, checked in by nit, 9 years ago

[titan] fix

File size: 65.1 KB
Line 
1#ifndef SCAN_H
2#define SCAN_H
3
4uint8_t changeservicetype(uint8_t type)
5{
6        int ret = type;
7
8        switch(type)
9        {
10                case 0x01:
11                case 0x06:
12                case 0x0B:
13                case 0x11:
14                case 0x16:
15                case 0x19:
16                case 0x1C:
17                case 0x9A:
18                case 0x86:
19                case 0xC3:
20                case 0xC5:
21                case 0xC6:
22                        ret = 0;
23                        break;
24                case 0x02:
25                case 0x07:
26                case 0x0A:
27                        ret = 1;
28                        break;
29        }
30
31        return ret;
32}
33
34struct transponder* satsystemdesc(unsigned char* buf, uint64_t transportid, unsigned short onid, int orbitalpos)
35{
36        int polarization = 0, modulation = 0, system = 0;
37        int rolloff = 0, fec = 0;
38        unsigned int frequency = 0, symbolrate = 0;
39        uint64_t id = 0;
40        struct transponder *tpnode = NULL;
41
42        if(buf == NULL) return NULL;
43
44        frequency = (
45                ((buf[2] >> 4) * 100000000) +
46                ((buf[2] & 0x0F) * 10000000) +
47                ((buf[3] >> 4) * 1000000) +
48                ((buf[3] & 0x0F) * 100000) +
49                ((buf[4] >> 4) * 10000) +
50                ((buf[4] & 0x0F) * 1000) +
51                ((buf[5] >> 4) * 100) +
52                ((buf[5] & 0x0F) * 10)
53        );
54
55        rolloff = (buf[8] >> 4) & 0x03; //0=rolloff_0_35, 1=rolloff_0_25, 2=rolloff_0_20, 3=rolloff_auto
56        system = (buf[8] >> 2) & 0x01; //0=DVB_S, 1=DVB_S2
57        modulation = (buf[8]) & 0x03; //1=QPSK, 2=PSK_8, 3=QAM_16
58
59        symbolrate = (
60                ((buf[9] >> 4) * 100000000) +
61                ((buf[9] & 0x0F) * 10000000) +
62                ((buf[10] >> 4) * 1000000) +
63                ((buf[10] & 0x0F) * 100000) +
64                ((buf[11] >> 4) * 10000) +
65                ((buf[11] & 0x0F) * 1000) +
66                ((buf[12] >> 4) * 100)
67        );
68
69        fec = (buf[12]) & 0x0F;
70
71        switch(fec)
72        {
73                case 0x01:
74                        fec = FEC_1_2;
75                        break;
76                case 0x02:
77                        fec = FEC_2_3;
78                        break;
79                case 0x03:
80                        fec = FEC_3_4;
81                        break;
82                case 0x04:
83                        fec = FEC_5_6;
84                        break;
85                case 0x05:
86                        fec = FEC_7_8;
87                        break;
88                case 0x06:
89                        fec = FEC_8_9;
90                        break;
91                case 0x07:
92                        fec = FEC_3_5;
93                        break;
94                case 0x08:
95                        fec = FEC_4_5;
96                        break;
97                case 0x09:
98                        fec = FEC_9_10;
99                        break;
100                case 0x0F:
101                        fec = FEC_NONE;
102                        break;
103                default:
104                        fec = FEC_AUTO;
105                        break;
106        }
107
108        polarization = (buf[8] >> 5) & 0x03; //0=H, 1=V
109
110        //workarounds for braindead broadcasters (e.g. on Telstar 12 at 15.0W)
111        if(frequency >= 100000000) frequency /= 10;
112        if(symbolrate >= 50000000) symbolrate /= 10;
113
114        frequency = (int)1000 * (int)round((double)frequency / (double)1000);
115
116        if(frequency > 15000000) return NULL;
117
118        id = ((onid << 16) | transportid) & 0xffffffff;
119
120        if(gettransponder(id) == NULL)
121        {
122                tpnode = createtransponder(id, FE_QPSK, orbitalpos, frequency, INVERSION_AUTO, symbolrate, polarization, fec, modulation, rolloff, 0, system);
123                status.writetransponder = 1;
124        }
125
126        debug(500, "nitscan: id=%llu freq=%d sr=%d fec=%d pol=%d modulation=%d system=%d tpnode=%p", id, frequency, symbolrate, fec, polarization, modulation, system, tpnode);
127
128        return tpnode;
129}
130
131struct transponder* cablesystemdesc(unsigned char* buf, uint64_t transportid, unsigned short onid, int orbitalpos)
132{
133        int modulation = 0, fec = 0;
134        unsigned int frequency = 0, symbolrate = 0;
135        uint64_t id = 0;
136        struct transponder *tpnode = NULL;
137
138        if(buf == NULL) return NULL;
139
140        frequency = (
141                ((buf[2] >> 4) * 1000000000) +
142                ((buf[2] & 0x0F) * 100000000) +
143                ((buf[3] >> 4) * 10000000) +
144                ((buf[3] & 0x0F) * 1000000) +
145                ((buf[4] >> 4) * 100000) +
146                ((buf[4] & 0x0F) * 10000) +
147                ((buf[5] >> 4) * 1000) +
148                ((buf[5] & 0x0F) * 100)
149        );
150
151        modulation = buf[8]; //0=QAM_AUTO, 1=QAM_16, 2=QAM_32, 3=QAM_64, 4=QAM_128, 5=QAM_256
152
153        symbolrate = (
154                ((buf[9] >> 4) * 100000000) +
155                ((buf[9] & 0x0F) * 10000000) +
156                ((buf[10] >> 4) * 1000000) +
157                ((buf[10] & 0x0F) * 100000) +
158                ((buf[11] >> 4) * 10000) +
159                ((buf[11] & 0x0F) * 1000) +
160                ((buf[12] >> 4) * 100)
161        );
162
163        fec = (buf[12]) & 0x0F;
164
165        switch(fec)
166        {
167                case 0x01:
168                        fec = FEC_1_2;
169                        break;
170                case 0x02:
171                        fec = FEC_2_3;
172                        break;
173                case 0x03:
174                        fec = FEC_3_4;
175                        break;
176                case 0x04:
177                        fec = FEC_5_6;
178                        break;
179                case 0x05:
180                        fec = FEC_7_8;
181                        break;
182                case 0x06:
183                        fec = FEC_8_9;
184                        break;
185                case 0x07:
186                        fec = FEC_3_5;
187                        break;
188                case 0x08:
189                        fec = FEC_4_5;
190                        break;
191                case 0x09:
192                        fec = FEC_9_10;
193                        break;
194                case 0x0F:
195                        fec = FEC_NONE;
196                        break;
197                default:
198                        fec = FEC_AUTO;
199                        break;
200        }
201
202        id = ((onid << 16) | transportid) & 0xffffffff;
203        id = id | ((uint64_t)1 << 32);
204
205        if(gettransponder(id) == NULL)
206        {
207                tpnode = createtransponder(id, FE_QAM, orbitalpos, frequency, INVERSION_AUTO, symbolrate, 0, fec, modulation, 0, 0, 0);
208                status.writetransponder = 1;
209        }
210
211        debug(500, "nitscan: id=%llu freq=%d sr=%d fec=%d modulation=%d tpnode=%p", id, frequency, symbolrate, fec, modulation, tpnode);
212
213        return tpnode;
214}
215
216struct transponder* terrsystemdesc(unsigned char* buf, uint64_t transportid, unsigned short onid, int orbitalpos)
217{
218        int modulation = 0, hp = 0, lp = 0;
219        int bandwidth = 0, hierarchy = 0, guardinterval = 0;
220        int transmission = 0;
221        unsigned int frequency = 0;
222        uint64_t id = 0;
223        struct transponder *tpnode = NULL;
224
225        if(buf == NULL) return NULL;
226
227        frequency = (buf[2] << 24) | (buf[3] << 16);
228        frequency |= (buf[4] << 8) | buf[5];
229        frequency *= 10;
230
231        bandwidth = BANDWIDTH_8_MHZ + ((buf[6] >> 5) & 0x3);
232        modulation = (buf[7] >> 6) & 0x3;
233        hierarchy = HIERARCHY_NONE + ((buf[7] >> 3) & 0x3);
234
235        hp = (buf[7] & 0x7);
236        switch(hp)
237        {
238                case 0x00:
239                        hp = FEC_1_2;
240                        break;
241                case 0x01:
242                        hp = FEC_2_3;
243                        break;
244                case 0x02:
245                        hp = FEC_3_4;
246                        break;
247                case 0x03:
248                        hp = FEC_5_6;
249                        break;
250                case 0x04:
251                        hp = FEC_7_8;
252                        break;
253                default:
254                        hp = FEC_AUTO;
255                        break;
256        }
257
258        lp = ((buf[8] >> 5) & 0x7);
259        switch(lp)
260        {
261                case 0x00:
262                        lp = FEC_1_2;
263                        break;
264                case 0x01:
265                        lp = FEC_2_3;
266                        break;
267                case 0x02:
268                        lp = FEC_3_4;
269                        break;
270                case 0x03:
271                        lp = FEC_5_6;
272                        break;
273                case 0x04:
274                        lp = FEC_7_8;
275                        break;
276                default:
277                        lp = FEC_AUTO;
278                        break;
279        }
280
281        guardinterval = GUARD_INTERVAL_1_32 + ((buf[8] >> 3) & 0x3);
282
283        transmission = (buf[8] & 0x2);
284        switch(transmission)
285        {
286                case 0x00:
287                        transmission = TRANSMISSION_MODE_2K;
288                        break;
289                case 0x01:
290                        transmission = TRANSMISSION_MODE_8K;
291                        break;
292                case 0x02:
293                        transmission = TRANSMISSION_MODE_AUTO;
294                        break;
295                default:
296                        transmission = TRANSMISSION_MODE_AUTO;
297                        break;
298        }
299
300        //other_frequency_flag = (buf[8] & 0x01);
301
302        id = ((onid << 16) | transportid) & 0xffffffff;
303        id = id | ((uint64_t)2 << 32);
304
305        if(gettransponder(id) == NULL)
306        {
307                tpnode = createtransponder(id, FE_OFDM, orbitalpos, frequency, INVERSION_AUTO, bandwidth, lp, hp, modulation, guardinterval, transmission, hierarchy);
308                status.writetransponder = 1;
309        }
310
311        debug(500, "nitscan: id=%llu freq=%d bandwidth=%d hp=%d lp=%d modulation=%d guard=%d trans=%d hierarchy=%d tpnode=%p", id, frequency, bandwidth, hp, lp, modulation, guardinterval, transmission, hierarchy, tpnode);
312
313        return tpnode;
314}
315
316int parsenit(unsigned char* buf, uint8_t* lastsecnr, int orbitalpos)
317{
318        int ret = 0;
319
320        if(buf == NULL) return ret;
321
322        //unsigned char buf[MINMALLOC];
323
324        // position in buffer
325        unsigned short pos = 0;
326        unsigned short pos2 = 0;
327
328        // network_information_section elements
329        unsigned short seclen = 0;
330        unsigned short desclen = 0;
331        unsigned short tdesclen = 0;
332        unsigned short looplen = 0;
333        uint64_t transponderid = 0;
334        unsigned short onid = 0;
335        unsigned short nid = 0;
336        unsigned char secnr = 0;
337
338        seclen = ((buf[1] & 0x0F) << 8) + buf[2];
339        nid = ((buf[3] << 8)| buf[4]);
340        desclen = ((buf[8] & 0x0F) << 8) | buf[9];
341        secnr = buf[6];
342        *lastsecnr = buf[7];
343        debug(500, "nitscan: section %d last %d nid %d", secnr, *lastsecnr, nid);
344
345        for(pos = 10; pos < desclen + 10; pos += buf[pos + 1] + 2)
346        {
347                switch(buf[pos])
348                {
349                        case 0x0F:
350                                //private_data_indicator_desc(buf + pos);
351                                break;
352                        case 0x40:
353                                //network_name_desc(buf + pos);
354                                break;
355                        case 0x4A:
356                                //linkage_desc(buf + pos);
357                                break;
358                        case 0x5B:
359                                //multilingual_networkname_desc(buf + pos);
360                                break;
361                        case 0x5F:
362                                //private_data_specifier_desc(buf + pos);
363                                break;
364                        case 0x80:
365                                break;
366                        case 0x90:
367                                break;
368                }
369        }
370
371        looplen = ((buf[pos] & 0x0F) << 8) | buf[pos + 1];
372        if (!looplen) return ret;
373
374        for(pos += 2; pos < seclen - 3; pos += tdesclen + 6)
375        {
376                transponderid = (buf[pos] << 8) | buf[pos + 1];
377                onid = (buf[pos + 2] << 8) | buf[pos + 3];
378                tdesclen = ((buf[pos + 4] & 0x0F) << 8) | buf[pos + 5];
379
380                for(pos2 = pos + 6; pos2 < pos + tdesclen + 6; pos2 += buf[pos2 + 1] + 2)
381                {
382                        switch(buf[pos2])
383                        {
384                                case 0x41:
385                                        //servicelistdesc(buf + pos2, transponderid, onid);
386                                        break;
387                                case 0x43:
388                                        if(satsystemdesc(buf + pos2, transponderid, onid, orbitalpos) != NULL)
389                                        {
390                                                scaninfo.tpnew++;
391                                                if(scaninfo.scantype != 0)
392                                                        scaninfo.tpmax++;
393                                        }
394                                        break;
395                                case 0x44:
396                                        if(cablesystemdesc(buf + pos2, transponderid, onid, orbitalpos) != NULL)
397                                        {
398                                                scaninfo.tpnew++;
399                                                if(scaninfo.scantype != 0)
400                                                        scaninfo.tpmax++;
401                                        }
402                                        break;
403                                case 0x5A:
404                                        if(terrsystemdesc(buf + pos2, transponderid, onid, orbitalpos) != NULL)
405                                        {
406                                                scaninfo.tpnew++;
407                                                if(scaninfo.scantype != 0)
408                                                        scaninfo.tpmax++;
409                                        }
410                                        break;
411                                case 0x62:
412                                        //frequencylistdesc(buf + pos2);
413                                        break;
414                        }
415                }
416        }
417
418        return ret;
419}
420
421//flag 0: from scan
422//flag 1: from update channelname
423int findchannel(struct dvbdev* fenode, struct transponder* tpnode, unsigned char *buf, uint8_t* lastsecnr, struct skin* scan, struct skin* listbox, int ichangename, int flag)
424{
425        int ret = -1, changed = 0;
426        uint64_t transponderid = 0;
427        struct skin* node = NULL;
428        struct channel* chnode = NULL;
429
430        // position in buffer
431        unsigned short pos;
432        unsigned short pos2;
433
434        // service_description_section elements
435        unsigned short seclen;
436        uint8_t secnr;
437        unsigned short onid, tid;
438        unsigned short serviceid;
439        unsigned short desclooplen;
440        unsigned short running;
441        int eitscheduleflag;
442        int eitpresentfollowingflag;
443        int camode;
444        uint8_t servicetype = 0;
445        uint8_t providerlen = 0;
446        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL;
447        uint64_t* tmpuint64 = NULL;
448
449        if(buf == NULL || fenode == NULL || fenode->feinfo == NULL) return ret;
450
451        seclen = ((buf[1] & 0x0F) << 8) | buf[2];
452        secnr = buf[6];
453        *lastsecnr = buf[7];
454        tid = (buf[3] << 8) | buf[4];
455        onid = (buf[8] << 8) | buf[9];
456       
457        transponderid = ((onid << 16) | tid) & 0xffffffff;
458        if(fenode->feinfo->type == FE_QAM)
459                transponderid = transponderid | ((uint64_t)1 << 32);
460        else if(fenode->feinfo->type == FE_OFDM)
461                transponderid = transponderid | ((uint64_t)2 << 32);
462        if(tpnode != NULL && tpnode->id != transponderid && tpnode->id != 99)
463        {
464                changetransponderid(tpnode, transponderid);
465                status.writetransponder = 1;
466        }
467
468        debug(500, "SDT nr: %d, lastnr: %d, len: %d, tid: %d, onid: %d, transponderid: %llu", secnr, *lastsecnr, seclen, tid, onid, transponderid);
469
470        for(pos = 11; pos < seclen - 1; pos += desclooplen + 5)
471        {
472                serviceid = (buf[pos] << 8) | buf[pos + 1];
473                eitscheduleflag = buf[pos + 2] & 0x02;
474                eitpresentfollowingflag = buf[pos + 2] & 0x01;
475                running = buf[pos + 3] & 0xE0;
476                camode = buf[pos + 3] & 0x10;
477                desclooplen = ((buf[pos + 3] & 0x0F) << 8) | buf[pos + 4];
478                if(flag == 0 && scaninfo.onlyfree == 1 && camode > 0) continue;
479
480                for(pos2 = pos + 5; pos2 < pos + desclooplen + 5; pos2 += buf[pos2 + 1] + 2)
481                {
482                        switch(buf[pos2])
483                        {
484                                case 0x48:
485                                        servicetype = buf[pos2 + 2];
486                                        servicetype = changeservicetype(servicetype);
487                                        providerlen = buf[pos2 + 3];
488                                       
489                                        //providername
490                                        tmpstr1 = strndup((char*)&(buf[pos2 + 4]), providerlen);
491                                        //channelname
492                                        tmpstr2 = strndup((char*)&(buf[pos2 + 4 + providerlen + 1]), (2 + buf[pos2 + 1]) - (4 + providerlen + 1));
493
494                                        tmpstr1 = string_strip_whitechars(tmpstr1);
495                                        tmpstr2 = string_strip_whitechars(tmpstr2);
496                                        if(tmpstr1 == NULL || strlen(tmpstr1) == 0) tmpstr1 = ostrcat(tmpstr1, "unknown", 1, 0);
497                                        if(tmpstr2 == NULL || strlen(tmpstr2) == 0) tmpstr2 = ostrcat(tmpstr2, "unknown", 1, 0);
498
499                                        tmpstr1 = strutf8(tpnode, tmpstr1, strlen(tmpstr1), 0, 1, 0);
500                                        tmpstr1 = stringreplacechar(tmpstr1, '#', '_');
501                                        tmpstr2 = strutf8(tpnode, tmpstr2, strlen(tmpstr2), 0, 1, 1);
502                                        tmpstr2 = stringreplacechar(tmpstr2, '#', '_');
503
504                                        //add to listbox
505                                        chnode = getchannel(serviceid, transponderid);
506                                        if(flag == 0) node = addlistbox(scan, listbox, node, 1);
507                                        if(node != NULL)
508                                        {
509                                                switch(servicetype)
510                                                {
511                                                        case 0:
512                                                                scaninfo.tvcount++;
513                                                                if(chnode == NULL) scaninfo.newtvcount++;
514                                                                break;
515                                                        case 1:
516                                                                scaninfo.radiocount++;
517                                                                if(chnode == NULL) scaninfo.newradiocount++;
518                                                                break;
519                                                        default:
520                                                                scaninfo.datacount++;
521                                                                if(chnode == NULL) scaninfo.newdatacount++;
522                                                                break;
523                                                }
524                                                tmpstr = ostrcat(tmpstr2, " (", 0, 0);
525                                                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 0);
526                                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
527                                                if(servicetype == 0)
528                                                        tmpstr = ostrcat(tmpstr, _("TV"), 1, 0);
529                                                else if(servicetype == 1)
530                                                        tmpstr = ostrcat(tmpstr, _("Radio"), 1, 0);
531                                                else
532                                                        tmpstr = ostrcat(tmpstr, _("Data"), 1, 0);
533
534                                                changed = 0;
535                                                if(chnode != NULL && chnode->name != NULL && strlen(chnode->name) > 0 && ostrcmp(tmpstr2, chnode->name) != 0)
536                                                {
537                                                        tmpstr = ostrcat(tmpstr, " - ", 1, 0);
538                                                        tmpstr = ostrcat(tmpstr, chnode->name, 1, 0);
539                                                        if(ichangename == 1) changed = 1;
540                                                }
541                                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
542                                                changetext(node, tmpstr);
543
544                                                if(chnode != NULL && chnode->transponder != NULL && changed == 0)
545                                                        node->fontcol = convertcol("deaktivcol");
546
547                                                changeparam1(node, tmpstr1);
548                                                changeparam2(node, tmpstr2);
549                                                tmpuint64 = (uint64_t*)calloc(1, sizeof(uint64_t) * 3);
550                                                if(tmpuint64 != NULL)
551                                                {
552                                                        tmpuint64[0] = serviceid;
553                                                        tmpuint64[1] = transponderid;
554                                                        tmpuint64[2] = servicetype;
555                                                }
556                                                free(node->name);
557                                                node->name = (char*)tmpuint64;
558                                        }
559                                       
560                                        if(flag == 1 && chnode != NULL && ostrcmp(chnode->name, tmpstr2) != 0)
561                                        {
562                                                free(chnode->name);
563                                                chnode->name = ostrcat(tmpstr2, NULL, 0, 0);
564                                                status.writechannel = 1;
565                                        }
566                                       
567                                        free(tmpstr); tmpstr = NULL;
568                                        free(tmpstr1); tmpstr1 = NULL;
569                                        free(tmpstr2); tmpstr2 = NULL;
570
571                                        ret = 0;
572                                        break;
573                        }
574                }
575        }
576
577        return ret;
578}
579
580uint64_t findtransponderid(struct dvbdev* fenode, unsigned char *buf)
581{
582        uint64_t transponderid = 0;
583        unsigned short onid, tid;
584
585        if(buf == NULL || fenode == NULL || fenode->feinfo == NULL) return 0;
586
587        tid = (buf[3] << 8) | buf[4];
588        onid = (buf[8] << 8) | buf[9];
589       
590        transponderid = ((onid << 16) | tid) & 0xffffffff;
591
592        if(fenode->feinfo->type == FE_QAM)
593                transponderid = transponderid | ((uint64_t)1 << 32);
594        else if(fenode->feinfo->type == FE_OFDM)
595                transponderid = transponderid | ((uint64_t)2 << 32);
596
597        debug(500, "found SDT transponderid: %llu", transponderid);
598
599        return transponderid;
600}
601
602unsigned int satblindscan(struct stimerthread* timernode, int onlycalc)
603{
604        int festatus = 0;
605        uint64_t transponderid = 0;
606        unsigned char* buf = NULL;
607        struct dvbdev* fenode = NULL;
608        struct transponder* tpnode = NULL;
609
610        unsigned int frequency = 0, symbolrate = 0;
611        int polarization = 0, modulation = 0, system = 0, fec = 0;
612
613        unsigned int minfrequency = getconfigint("blindminfrequency", NULL) * 1000;
614        unsigned int maxfrequency = getconfigint("blindmaxfrequency", NULL) * 1000;
615        unsigned int stepfrequency = getconfigint("blindstepfrequency", NULL) * 1000;
616        unsigned int minsymbolrate = getconfigint("blindminsignalrate", NULL) * 1000;
617        unsigned int maxsymbolrate = getconfigint("blindmaxsignalrate", NULL) * 1000;
618        unsigned int stepsymbolrate = getconfigint("blindstepsignalrate", NULL) * 1000;
619        unsigned int usedefaultsr = getconfigint("blindusedefaultsr", NULL);
620        unsigned int onlydvbs = getconfigint("blindonlydvbs", NULL);
621        unsigned int usedefaultfec = getconfigint("blindusedefaultfec", NULL);
622       
623        int minmodulation = 1, maxmodulation = 2, stepmodulation = 1;
624        int minpolarization = 0, maxpolarization = 1, steppolarization = 1;
625        int minsystem = 0, maxsystem = 1, stepsystem = 1;
626        int minfec = 0, maxfec = 8, stepfec = 1;
627
628        if(onlydvbs == 1)
629        {
630                maxmodulation = 0;
631                maxsystem = 0;
632        }
633
634        if(usedefaultsr == 1)
635        {
636                minsymbolrate = 0;
637                maxsymbolrate = 3;
638                stepsymbolrate = 1;
639        }
640
641        if(usedefaultfec == 1)
642                maxfec = 6;
643
644        int countfrequency = ((maxfrequency + stepfrequency) - minfrequency) / stepfrequency;
645        int countsymbolrate = ((maxsymbolrate + stepsymbolrate) - minsymbolrate) / stepsymbolrate;
646        int countmodulation = ((maxmodulation + stepmodulation) - minmodulation) / stepmodulation;
647        int countpolarization = ((maxpolarization + steppolarization) - minpolarization) / steppolarization;
648        int countfec = ((maxfec + stepfec) - minfec) / stepfec;
649        int systemcount = ((maxsystem + stepsystem) - minsystem) / stepsystem;
650       
651        if(onlycalc == 1) return systemcount * countpolarization * countmodulation * countsymbolrate * countfrequency * countfec;
652
653        if(scaninfo.fenode == NULL || timernode == NULL) return -1;
654        int timeout = scaninfo.timeout / 5;
655        if(timeout < 1000000) timeout = 1000000;
656        scaninfo.blindmax += systemcount * countpolarization * countmodulation * countsymbolrate * countfrequency * countfec;
657
658        for(frequency = minfrequency; frequency <= maxfrequency; frequency += stepfrequency)
659        {
660
661                int csymbolrate = 0;
662                for(csymbolrate = minsymbolrate; csymbolrate <= maxsymbolrate; csymbolrate += stepsymbolrate)
663                {
664                        if(usedefaultsr == 1)
665                        {
666                                switch(csymbolrate)
667                                {
668                                        case 0:
669                                                symbolrate = 22000 * 1000;
670                                                break;
671                                        case 1:
672                                                symbolrate = 27500 * 1000;
673                                                break;
674                                        case 2:
675                                                symbolrate = 30000 * 1000;
676                                                break;
677                                }
678                        }
679                        else
680                                symbolrate = csymbolrate;
681
682                        for(modulation = minmodulation; modulation <= maxmodulation; modulation += stepmodulation)
683                        {
684                               
685                                for(polarization = minpolarization; polarization <= maxpolarization; polarization += steppolarization)
686                                {
687
688                                        for(fec = minfec; fec <= maxfec; fec += stepfec)
689                                        {
690
691                                                for(system = minsystem; system <= maxsystem; system += stepsystem)
692                                                {
693                                                        scaninfo.blindcount++;
694
695                                                        tpnode = createtransponder(99, scaninfo.fenode->feinfo->type, scaninfo.orbitalpos, frequency, INVERSION_AUTO, symbolrate, polarization, fec, modulation, 0, 0, system);
696
697                                                        debug(500, "blindscan: frequ=%d, sr=%d, modulation=%d, fec=%d, system=%d, orbitalpos=%d", frequency, symbolrate, modulation, fec, system, scaninfo.orbitalpos);
698
699                                                        if(tpnode != NULL)
700                                                        {
701
702                                                                fenode = fegetfree(tpnode, 0, scaninfo.fenode);
703                                                                if(fenode == NULL )
704                                                                {
705                                                                        debug(500, "Frontend for scan not free");
706                                                                        deltransponderbyid(99);
707                                                                        continue;
708                                                                }
709
710                                                                //frontend tune
711                                                                if(fenode->feinfo->type == FE_QPSK)
712                                                                {
713                                                                        feset(fenode, tpnode);
714                                                                        fetunedvbs(fenode, tpnode);
715                                                                }
716                                                                else
717                                                                {
718                                                                        debug(500, "Frontend type unknown");
719                                                                        deltransponderbyid(99);
720                                                                        continue;
721                                                                }
722
723                                                                festatus = fewait(fenode);
724                                                                if(debug_level == 200) fereadstatus(fenode);
725                                                                if(festatus != 0)
726                                                                {
727                                                                        debug(500, "tuning failed");
728                                                                        deltransponderbyid(99);
729                                                                        continue;
730                                                                }
731
732                                                                buf = dvbgetsdt(fenode, 0, timeout);
733                                                                transponderid = findtransponderid(fenode, buf);
734                                                                free(buf); buf = NULL;
735
736                                                                if(transponderid == 0 || gettransponder(transponderid) != NULL)
737                                                                {
738                                                                        deltransponderbyid(99);
739                                                                        continue;
740                                                                }
741
742                                                                if(tpnode->id != transponderid)
743                                                                {
744                                                                        scaninfo.newblindcount++;
745                                                                        changetransponderid(tpnode, transponderid);
746                                                                        status.writetransponder = 1;
747                                                                }
748                                                        }
749                                                        deltransponderbyid(99);
750                                                        if(timernode->aktion != START) break;
751                                                }
752                                                if(timernode->aktion != START) break;
753                                        }
754                                        if(timernode->aktion != START) break;
755                                }
756                                if(timernode->aktion != START) break;
757                        }
758                        if(timernode->aktion != START) break;
759                }
760                if(timernode->aktion != START) break;
761        }
762       
763        return 0;
764}
765
766unsigned int cableblindscan(struct stimerthread* timernode, int onlycalc)
767{
768        int festatus = 0;
769        uint64_t transponderid = 0;
770        unsigned char* buf = NULL;
771        struct dvbdev* fenode = NULL;
772        struct transponder* tpnode = NULL;
773
774        unsigned int frequency = 0, symbolrate = 0;
775        int modulation = 0, fec = 0;
776
777        unsigned int minfrequency = getconfigint("cblindminfrequency", NULL) * 1000;
778        unsigned int maxfrequency = getconfigint("cblindmaxfrequency", NULL) * 1000;
779        unsigned int stepfrequency = getconfigint("cblindstepfrequency", NULL) * 1000;
780        unsigned int minsymbolrate = getconfigint("cblindminsignalrate", NULL) * 1000;
781        unsigned int maxsymbolrate = getconfigint("cblindmaxsignalrate", NULL) * 1000;
782        unsigned int stepsymbolrate = getconfigint("cblindstepsignalrate", NULL) * 1000;
783        unsigned int usedefaultsr = getconfigint("cblindusedefaultsr", NULL);
784        unsigned int usedefaultfec = getconfigint("cblindusedefaultfec", NULL);
785       
786        int minmodulation = 0, maxmodulation = 4, stepmodulation = 1;
787        int minfec = 0, maxfec = 8, stepfec = 1;
788
789        if(usedefaultsr == 1)
790        {
791                minsymbolrate = 0;
792                maxsymbolrate = 3;
793                stepsymbolrate = 1;
794        }
795
796        if(usedefaultfec == 1)
797                maxfec = 6;
798
799        int countfrequency = ((maxfrequency + stepfrequency) - minfrequency) / stepfrequency;
800        int countsymbolrate = ((maxsymbolrate + stepsymbolrate) - minsymbolrate) / stepsymbolrate;
801        int countmodulation = ((maxmodulation + stepmodulation) - minmodulation) / stepmodulation;
802        int countfec = ((maxfec + stepfec) - minfec) / stepfec;
803       
804        if(onlycalc == 1) return countmodulation * countsymbolrate * countfrequency * countfec;
805       
806        if(scaninfo.fenode == NULL || timernode == NULL) return -1;
807        int timeout = scaninfo.timeout / 5;
808        if(timeout < 1000000) timeout = 1000000;
809        scaninfo.blindmax += countmodulation * countsymbolrate * countfrequency * countfec;
810
811        for(frequency = minfrequency; frequency <= maxfrequency; frequency += stepfrequency)
812        {
813
814                int csymbolrate = 0;
815                for(csymbolrate = minsymbolrate; csymbolrate <= maxsymbolrate; csymbolrate += stepsymbolrate)
816                {
817                        if(usedefaultsr == 1)
818                        {
819                                switch(csymbolrate)
820                                {
821                                        case 0:
822                                                symbolrate = 22000 * 1000;
823                                                break;
824                                        case 1:
825                                                symbolrate = 27500 * 1000;
826                                                break;
827                                        case 2:
828                                                symbolrate = 30000 * 1000;
829                                                break;
830                                }
831                        }
832                        else
833                                symbolrate = csymbolrate;
834
835                        for(modulation = minmodulation; modulation <= maxmodulation; modulation += stepmodulation)
836                        {
837
838                                for(fec = minfec; fec <= maxfec; fec += stepfec)
839                                {
840                                        scaninfo.blindcount++;
841
842                                        tpnode = createtransponder(99, scaninfo.fenode->feinfo->type, scaninfo.orbitalpos, frequency, INVERSION_AUTO, symbolrate, 0, fec, modulation, 0, 0, 0);
843
844                                        debug(500, "blindscan: frequ=%d, sr=%d, modulation=%d, fec=%d, orbitalpos=%d", frequency, symbolrate, modulation, fec, scaninfo.orbitalpos);
845
846                                        if(tpnode != NULL)
847                                        {
848
849                                                fenode = fegetfree(tpnode, 0, scaninfo.fenode);
850                                                if(fenode == NULL )
851                                                {
852                                                        debug(500, "Frontend for scan not free");
853                                                        deltransponderbyid(99);
854                                                        continue;
855                                                }
856
857                                                //frontend tune
858                                                if(fenode->feinfo->type == FE_QAM)
859                                                        fetunedvbc(fenode, tpnode);
860                                                else
861                                                {
862                                                        debug(500, "Frontend type unknown");
863                                                        deltransponderbyid(99);
864                                                        continue;
865                                                }
866
867                                                festatus = fewait(fenode);
868                                                if(debug_level == 200) fereadstatus(fenode);
869                                                if(festatus != 0)
870                                                {
871                                                        debug(500, "tuning failed");
872                                                        deltransponderbyid(99);
873                                                        continue;
874                                                }
875
876                                                buf = dvbgetsdt(fenode, 0, timeout);
877                                                transponderid = findtransponderid(fenode, buf);
878                                                free(buf); buf = NULL;
879
880                                                if(transponderid == 0 || gettransponder(transponderid) != NULL)
881                                                {
882                                                        deltransponderbyid(99);
883                                                        continue;
884                                                }
885
886                                                if(tpnode->id != transponderid)
887                                                {
888                                                        scaninfo.newblindcount++;
889                                                        changetransponderid(tpnode, transponderid);
890                                                        status.writetransponder = 1;
891                                                }
892                                        }
893                                        deltransponderbyid(99);
894                                        if(timernode->aktion != START) break;
895                                }
896                                if(timernode->aktion != START) break;
897                        }
898                        if(timernode->aktion != START) break;
899                }
900                if(timernode->aktion != START) break;
901        }
902       
903        return 0;
904}
905
906unsigned int terrblindscan(struct stimerthread* timernode, int onlycalc)
907{
908        int festatus = 0;
909        uint64_t transponderid = 0;
910        unsigned char* buf = NULL;
911        struct dvbdev* fenode = NULL;
912        struct transponder* tpnode = NULL;
913
914        unsigned int frequency = 0;
915        int hp = 0, lp = 0, modulation = 0, bandwidth = 0, transmission = 0, guardinterval = 0, hierarchy = 0;
916
917        unsigned int minfrequency = getconfigint("tblindminfrequency", NULL) * 1000;
918        unsigned int maxfrequency = getconfigint("tblindmaxfrequency", NULL) * 1000;
919        unsigned int stepfrequency = getconfigint("tblindstepfrequency", NULL) * 1000;
920       
921        int minhp = 0, maxhp = 3, stephp = 1;
922        int minlp = 0, maxlp = 3, steplp = 1;
923        int minmodulation = 0, maxmodulation = 2, stepmodulation = 1;
924        int minbandwidth = 0, maxbandwidth = 2, stepbandwidth = 1;
925        int mintransmission = 0, maxtransmission = 1, steptransmission = 1;
926        int minguardinterval = 0, maxguardinterval = 3, stepguardinterval = 1;
927        int minhierarchy = 0, maxhierarchy = 3, stephierarchy = 1;
928
929        int countfrequency = ((maxfrequency + stepfrequency) - minfrequency) / stepfrequency;
930        int counthp = ((maxhp + stephp) - minhp) / stephp;
931        int countlp = ((maxlp + steplp) - minlp) / steplp;
932        int countmodulation = ((maxmodulation + stepmodulation) - minmodulation) / stepmodulation;
933        int countbandwidth = ((maxbandwidth + stepbandwidth) - minbandwidth) / stepbandwidth;
934        int counttransmission = ((maxtransmission + steptransmission) - mintransmission) / steptransmission;
935        int countguardinterval = ((maxguardinterval + stepguardinterval) - minguardinterval) / stepguardinterval;
936        int counthierarchy = ((maxhierarchy + stephierarchy) - minhierarchy) / stephierarchy;
937       
938        if(onlycalc == 1) return counthierarchy * countguardinterval * countmodulation * counttransmission * countfrequency * countbandwidth * countlp * counthp;
939       
940        if(scaninfo.fenode == NULL || timernode == NULL) return -1;
941        int timeout = scaninfo.timeout / 5;
942        if(timeout < 1000000) timeout = 1000000;
943        scaninfo.blindmax += counthierarchy * countguardinterval * countmodulation * counttransmission * countfrequency * countbandwidth * countlp * counthp;
944
945        for(frequency = minfrequency; frequency <= maxfrequency; frequency += stepfrequency)
946        {
947
948                for(hp = minhp; hp <= maxhp; hp += stephp)
949                {
950
951                        for(lp = minlp; lp <= maxlp; lp += steplp)
952                        {
953
954                                for(modulation = minmodulation; modulation <= maxmodulation; modulation += stepmodulation)
955                                {
956
957                                        for(bandwidth = minbandwidth; bandwidth <= maxbandwidth; bandwidth += stepbandwidth)
958                                        {
959
960                                                for(transmission = mintransmission; transmission <= maxtransmission; transmission += steptransmission)
961                                                {
962                                               
963                                                        for(guardinterval = minguardinterval; guardinterval <= maxguardinterval; guardinterval += stepguardinterval)
964                                                        {
965                                               
966                                                                for(hierarchy = minhierarchy; hierarchy <= maxhierarchy; hierarchy += stephierarchy)
967                                                                {
968                                                                        scaninfo.blindcount++;
969       
970                                                                        tpnode = createtransponder(99, scaninfo.fenode->feinfo->type, scaninfo.orbitalpos, frequency, INVERSION_AUTO, bandwidth, lp, hp, modulation, guardinterval, transmission, hierarchy);
971       
972                                                                        debug(500, "blindscan: frequ=%d, modulation=%d, hp=%d, lp=%d, bandwidth=%d, guardinterval=%d, transmission=%d, hierarchy=%d, orbitalpos=%d", frequency, modulation, hp, lp, bandwidth, guardinterval, transmission, hierarchy, scaninfo.orbitalpos);
973       
974                                                                        if(tpnode != NULL)
975                                                                        {
976       
977                                                                                fenode = fegetfree(tpnode, 0, scaninfo.fenode);
978                                                                                if(fenode == NULL )
979                                                                                {
980                                                                                        debug(500, "Frontend for scan not free");
981                                                                                        deltransponderbyid(99);
982                                                                                        continue;
983                                                                                }
984       
985                                                                                //frontend tune
986                                                                                if(fenode->feinfo->type == FE_OFDM)
987                                                                                {
988                                                                                        feset(fenode, tpnode);
989                                                                                        fetunedvbs(fenode, tpnode);
990                                                                                }
991                                                                                else
992                                                                                {
993                                                                                        debug(500, "Frontend type unknown");
994                                                                                        deltransponderbyid(99);
995                                                                                        continue;
996                                                                                }
997               
998                                                                                festatus = fewait(fenode);
999                                                                                if(debug_level == 200) fereadstatus(fenode);
1000                                                                                if(festatus != 0)
1001                                                                                {
1002                                                                                        debug(500, "tuning failed");
1003                                                                                        deltransponderbyid(99);
1004                                                                                        continue;
1005                                                                                }
1006               
1007                                                                                buf = dvbgetsdt(fenode, 0, timeout);
1008                                                                                transponderid = findtransponderid(fenode, buf);
1009                                                                                free(buf); buf = NULL;
1010               
1011                                                                                if(transponderid == 0 || gettransponder(transponderid) != NULL)
1012                                                                                {
1013                                                                                        deltransponderbyid(99);
1014                                                                                        continue;
1015                                                                                }
1016       
1017                                                                                if(tpnode->id != transponderid)
1018                                                                                {
1019                                                                                        scaninfo.newblindcount++;
1020                                                                                        changetransponderid(tpnode, transponderid);
1021                                                                                        status.writetransponder = 1;
1022                                                                                }
1023                                                                        }
1024                                                                        deltransponderbyid(99);
1025                                                                        if(timernode->aktion != START) break;
1026                                                                }
1027                                                                if(timernode->aktion != START) break;
1028                                                        }
1029                                                        if(timernode->aktion != START) break;
1030                                                }
1031                                                if(timernode->aktion != START) break;
1032                                        }
1033                                        if(timernode->aktion != START) break;
1034                                }
1035                                if(timernode->aktion != START) break;
1036                        }
1037                        if(timernode->aktion != START) break;
1038                }
1039                if(timernode->aktion != START) break;
1040        }
1041       
1042        return 0;
1043}
1044
1045void blindscan(struct stimerthread* timernode)
1046{
1047        if(scaninfo.fenode == NULL) return;
1048       
1049        if(scaninfo.fenode->feinfo->type == FE_QPSK)
1050                satblindscan(timernode, 0);
1051        else if(scaninfo.fenode->feinfo->type == FE_QAM)
1052                cableblindscan(timernode, 0);
1053        else if(scaninfo.fenode->feinfo->type == FE_OFDM)
1054                terrblindscan(timernode, 0);
1055}
1056
1057void doscan(struct stimerthread* timernode)
1058{
1059        int festatus = 0, secnr = 0;
1060        uint8_t lastsecnr = 0xff;
1061        unsigned char* buf = NULL;
1062        struct transponder* tpnode = NULL;
1063        struct dvbdev* fenode = NULL;
1064        //struct channel* chnode = NULL;
1065        struct sat* satnode = sat;
1066        int nitscan = 1;
1067
1068        if(scaninfo.fenode == NULL || scaninfo.tpnode == NULL || timernode == NULL)
1069        {
1070                scaninfo.threadend = 1;
1071                return;
1072        }
1073
1074        debug(500, "channel scan thread start");
1075
1076        //sat loop
1077        satnode = sat;
1078        while(satnode != NULL && timernode->aktion == START)
1079        {
1080                if(satnode->scan == 0)
1081                {
1082                        satnode = satnode->next;
1083                        continue;
1084                }
1085                scaninfo.satname = satnode->name;
1086
1087                if(scaninfo.scantype == 0)
1088                        tpnode = scaninfo.tpnode;
1089                else if(scaninfo.scantype == 1)
1090                        tpnode = transponder;
1091                else if(scaninfo.scantype == 2 || scaninfo.scantype == 3)
1092                {
1093                        tpnode = transponder;
1094                        scaninfo.orbitalpos = satnode->orbitalpos;
1095                }
1096
1097                if(scaninfo.blindscan == 1) blindscan(timernode);
1098               
1099                nitscan = 1;
1100                //transponder loop
1101                while(tpnode != NULL && timernode->aktion == START)
1102                {
1103                        if(scaninfo.orbitalpos != tpnode->orbitalpos)
1104                        {
1105                                tpnode = tpnode->next;
1106                                if(scaninfo.scantype == 0) break;
1107                                continue;
1108                        }
1109       
1110                        fenode = fegetfree(tpnode, 0, scaninfo.fenode);
1111                        if(fenode == NULL || (scaninfo.scantype != 3 && fenode != scaninfo.fenode))
1112                        {
1113                                scaninfo.tpcount++;
1114                                tpnode = tpnode->next;
1115                                debug(500, "Frontend for scan not free");
1116                                if(scaninfo.scantype == 0) break;
1117                                continue;
1118                        }
1119
1120                        //frontend tune
1121                        if(fenode->feinfo->type == FE_QPSK)
1122                        {
1123                                feset(fenode, tpnode);
1124                                if(fetunedvbs(fenode, tpnode) != 0)
1125                                {
1126                                        scaninfo.tpcount++;
1127                                        tpnode = tpnode->next;
1128                                        debug(500, "tuning failed");
1129                                        if(scaninfo.scantype == 0) break;
1130                                        continue;
1131                                }
1132                        }
1133                        else if(fenode->feinfo->type == FE_QAM)
1134                        {
1135                                fetunedvbc(fenode, tpnode) != 0)
1136                                {
1137                                        scaninfo.tpcount++;
1138                                        tpnode = tpnode->next;
1139                                        debug(500, "tuning failed");
1140                                        if(scaninfo.scantype == 0) break;
1141                                        continue;
1142                                }
1143                        }
1144                        else if(fenode->feinfo->type == FE_OFDM)
1145                        {
1146                                if(fetunedvbt(fenode, tpnode) != 0)
1147                                {
1148                                        scaninfo.tpcount++;
1149                                        tpnode = tpnode->next;
1150                                        debug(500, "tuning failed");
1151                                        if(scaninfo.scantype == 0) break;
1152                                        continue;
1153                                }
1154                        }
1155                        else
1156                        {
1157                                scaninfo.tpcount++;
1158                                tpnode = tpnode->next;
1159                                debug(500, "Frontend type unknown");
1160                                if(scaninfo.scantype == 0) break;
1161                                continue;
1162                        }
1163
1164                        festatus = fewait(fenode);
1165                        if(debug_level == 200) fereadstatus(fenode);
1166                        if(festatus != 0)
1167                        {
1168                                scaninfo.tpcount++;
1169                                tpnode = tpnode->next;
1170                                debug(500, "tuning failed last");
1171                                if(scaninfo.scantype == 0) break;
1172                                continue;
1173                        }
1174
1175                        //del channels from transponder if selected
1176                        //if(scaninfo.scantype != 3 && scaninfo.clear == 1)
1177                        //{
1178                        //      struct channel* tmpchannel = NULL;
1179                        //      chnode = channel;
1180                        //      while(chnode != NULL)
1181                        //      {
1182                        //              tmpchannel = chnode->next;
1183                        //              if(chnode->transponder == tpnode)
1184                        //                      delchannel(chnode->serviceid, chnode->transponderid, 1);
1185                        //              chnode = tmpchannel;
1186                        //      }
1187                        //}
1188
1189                        //get nit
1190                        if(scaninfo.networkscan == 1 && nitscan == 1)
1191                        {
1192                                lastsecnr = 0xff;
1193                                secnr = 0;
1194                                while(secnr <= lastsecnr && secnr <= 256)
1195                                {
1196                                        if(timernode->aktion != START) break;
1197                                        buf = dvbgetnit(fenode, secnr, scaninfo.timeout * 2);
1198                                        if(buf != NULL)
1199                                        {
1200                                                parsenit(buf, &lastsecnr, satnode->orbitalpos);
1201                                                nitscan = 1; //1 = scan all transponder for nit / 0 = scan only first transponder for nit
1202                                        }
1203                                        else
1204                                                break;
1205                                        free(buf); buf = NULL;
1206                                        secnr++;
1207                                }
1208                        }
1209
1210                        lastsecnr = 0xff;
1211                        secnr = 0;
1212                        while(secnr <= lastsecnr && secnr <= 256)
1213                        {
1214                                if(timernode->aktion != START) break;
1215#ifndef SIMULATE
1216                                buf = dvbgetsdt(fenode, secnr, scaninfo.timeout);
1217#endif
1218                                if(buf != NULL)
1219                                        findchannel(fenode, tpnode, buf, &lastsecnr, scaninfo.scanscreen, scaninfo.listbox, scaninfo.changename, 0);
1220                                else
1221                                        break;
1222                                free(buf); buf = NULL;
1223                                secnr++;
1224                        }
1225       
1226                        scaninfo.tpcount++;
1227                        if(scaninfo.scantype == 0) break;
1228                        tpnode = tpnode->next;
1229                }
1230                if(scaninfo.scantype == 0 || scaninfo.scantype == 1) break;
1231                satnode = satnode->next;
1232        }
1233        scaninfo.threadend = 1;
1234        debug(500, "channel scan thread end");
1235}
1236
1237void scanaddchannel(struct skin* node, int scantype, struct transponder* tp1, int ichangename)
1238{
1239        int serviceid = 0;
1240        uint64_t transponderid = 0;
1241        int servicetype = 0;
1242        int providerid = 0;
1243        struct provider* providernode = NULL;
1244        char* tmpstr = NULL;
1245        struct transponder* tp2 = NULL;
1246        struct channel* chnode = NULL;
1247
1248        if(node == NULL || node->name == NULL) return;
1249
1250        serviceid = ((uint64_t*)node->name)[0];
1251        transponderid = ((uint64_t*)node->name)[1];
1252        servicetype = ((uint64_t*)node->name)[2];
1253
1254        chnode = getchannel(serviceid, transponderid);
1255        if(chnode == NULL || (chnode != NULL && chnode->transponder == NULL))
1256        {
1257                //check if provider valid
1258                providernode = getproviderbyname(node->param1);
1259                if(providernode != NULL)
1260                        providerid = providernode->providerid;
1261                else
1262                {
1263                        providerid = getlastproviderid() + 1;
1264                        tmpstr = ostrcat(tmpstr, oitoa(providerid), 1, 1);
1265                        tmpstr = ostrcat(tmpstr, "#", 1, 0);
1266                        tmpstr = ostrcat(tmpstr, node->param1, 1, 0);
1267                        tmpstr = ostrcat(tmpstr, "#0", 1, 0);
1268                        addprovider(tmpstr, 1, NULL);
1269                        free(tmpstr); tmpstr = NULL;
1270                }
1271
1272                //check if transponder valid
1273                if(scantype == 0)
1274                {
1275                        tp2 = gettransponder(transponderid);
1276
1277                        if(tp2 == NULL && tp1 != NULL)
1278                        {
1279                                tp2 = gettransponderbydetail(0, tp1->fetype, tp1->orbitalpos, tp1->frequency, tp1->inversion, tp1->symbolrate, tp1->polarization, tp1->fec, tp1->modulation, tp1->rolloff, tp1->pilot, tp1->system, 1);
1280                                if(tp2 != NULL)
1281                                        changetransponderid(tp2, transponderid);
1282                        }
1283
1284                        if(tp2 == NULL) //create new transponder
1285                                copytransponder(tp1, tp2, transponderid);
1286                        else //change transponder
1287                                copytransponder(tp1, tp2, 99);
1288                }
1289
1290                if(servicetype != 0 && servicetype != 1)
1291                        servicetype = 0;
1292
1293                if(chnode == NULL)
1294                {
1295                        if(createchannel(node->param2, transponderid, providerid, serviceid, servicetype, 0, -1, -1, -1, -1, 0) != NULL)
1296                                node->fontcol = convertcol("deaktivcol");
1297                }
1298                else
1299                        node->fontcol = convertcol("deaktivcol");
1300        }
1301        else
1302        {
1303                node->fontcol = convertcol("deaktivcol");
1304                //change channel name if selected
1305                if(ichangename == 1 && node->param2 != NULL && strlen(node->param2) > 0 && ostrcmp(node->param2, chnode->name) != 0)
1306                {
1307                        free(chnode->name);
1308                        chnode->name = ostrcat(node->param2, NULL, 0, 0);
1309                        status.writetransponder = 1;
1310                }
1311        }
1312}
1313
1314void scansetallsat(int fetype)
1315{
1316        int i = 0, orbitalpos = 0;
1317        struct sat* satnode = NULL;
1318        struct dvbdev* dvbnode = dvbdev;
1319        char* tmpstr = NULL, *tmpnr = NULL;
1320
1321        while(dvbnode != NULL)
1322        {
1323                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo != NULL && dvbnode->felock < 1 && (fetype == -1 || dvbnode->feinfo->type == fetype))
1324                {
1325
1326                        tmpstr = ostrcat(dvbnode->feshortname, "_sat", 0, 0);
1327                        for(i = 1; i <= getmaxsat(dvbnode->feshortname); i++)
1328                        {
1329                                tmpnr = oitoa(i);
1330                                orbitalpos = getconfigint(tmpstr, tmpnr);
1331                                free(tmpnr); tmpnr = NULL;
1332
1333                                satnode = getsatbyorbitalpos(orbitalpos);
1334                                if(satnode != NULL && (fetype == -1 || satnode->fetype == fetype))
1335                                        satnode->scan = 1;
1336                        }
1337                        free(tmpstr); tmpstr = NULL;
1338                }
1339                dvbnode = dvbnode->next;
1340        }
1341}
1342
1343void scansetmultisat(struct skin* scan)
1344{
1345        struct skin* node = scan;
1346        struct sat* satnode = NULL;
1347
1348        while(node != NULL && node->name != NULL)
1349        {
1350                if(ostrcmp(node->ret, "1") == 0)
1351                {
1352                        satnode = getsatbyorbitalpos(atoi(node->name));
1353                        if(satnode != NULL)
1354                                satnode->scan = 1;
1355                }
1356                node = node->next;
1357        }
1358}
1359
1360void delchannelbysat(int orbitalpos)
1361{
1362        struct transponder* transpondernode = transponder;
1363        struct channel* chnode = NULL;
1364
1365        while(transpondernode != NULL)
1366        {
1367                if(transpondernode->orbitalpos == orbitalpos)
1368                {
1369                        struct channel* tmpchannel = NULL;
1370                        chnode = channel;
1371                        while(chnode != NULL)
1372                        {
1373                                tmpchannel = chnode->next;
1374                                if(chnode->transponder == transpondernode)
1375                                        delchannel(chnode->serviceid, chnode->transponderid, 1);
1376                                chnode = tmpchannel;
1377                        }
1378                }
1379                transpondernode = transpondernode->next;
1380        }
1381}
1382
1383void delchannelbymultisat()
1384{
1385        struct sat* satnode = sat;
1386
1387        while(satnode != NULL)
1388        {
1389                if(satnode->scan == 1)
1390                        delchannelbysat(satnode->orbitalpos);
1391                satnode = satnode->next;
1392        }
1393}
1394
1395void screenscan(struct transponder* transpondernode, struct skin* mscan, char* tuner, int scantype, int orbitalpos, unsigned int frequency, int inversion, unsigned int symbolrate, int polarization, int fec, int modulation, int rolloff, int pilot, int networkscan, int onlyfree, int clear, int blindscan, int ichangename, int system, int timeout)
1396{
1397        int rcret = 0, tpmax = 0, i = 0, alladded = 0;
1398        struct skin* scan = getscreen("scan");
1399        struct skin* progress = getscreennode(scan, "progress");
1400        struct skin* listbox = getscreennode(scan, "listbox");
1401        struct skin* satname = getscreennode(scan, "satname");
1402        struct skin* tpcount = getscreennode(scan, "tpcount");
1403        struct skin* foundtv = getscreennode(scan, "foundtv");
1404        struct skin* foundradio = getscreennode(scan, "foundradio");
1405        struct skin* founddata = getscreennode(scan, "founddata");
1406        struct skin* foundblind = getscreennode(scan, "foundblind");
1407        struct skin* b2 = getscreennode(scan, "b2");
1408        struct skin* b3 = getscreennode(scan, "b3");
1409        struct skin* load = getscreen("loading");
1410        struct transponder* tpnode = NULL;
1411        struct dvbdev* fenode = NULL, *dvbnode = dvbdev;
1412        struct stimerthread* timernode = NULL;
1413        struct sat* satnode = NULL;
1414        struct channel* chnode = NULL;
1415        char* tmpstr = NULL;
1416
1417        listbox->aktline = 1;
1418        listbox->aktpage = -1;
1419        progress->progresssize = 0;
1420        memset(&scaninfo, 0, sizeof(struct scaninfo));
1421
1422        b2->hidden = NO;
1423        b3->hidden = NO;
1424
1425        addscreenrc(scan, listbox);
1426        if(scantype != 3)
1427        {
1428                while(dvbnode != NULL)
1429                {
1430                        if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo != NULL && dvbnode->felock < 1)
1431                        {
1432                                if(ostrcmp(dvbnode->feshortname, tuner) == 0)
1433                                {
1434                                        fenode = dvbnode;
1435                                        break;
1436                                }
1437                        }
1438                        dvbnode = dvbnode->next;
1439                }
1440                if(fenode == NULL) return;
1441        }
1442        else if(scantype == 3)
1443                fenode = dvbdev;
1444
1445        if(scantype == 0) //single transponder
1446        {
1447                if(fenode != NULL && fenode->feinfo != NULL)
1448                {
1449                        //del channels from transponder if selected
1450                        if(clear == 1)
1451                        {
1452                                struct channel* tmpchannel = NULL;
1453                                chnode = channel;
1454                                while(chnode != NULL)
1455                                {
1456                                        tmpchannel = chnode->next;
1457                                        if(chnode->transponder == transpondernode)
1458                                                delchannel(chnode->serviceid, chnode->transponderid, 1);
1459                                        chnode = tmpchannel;
1460                                }
1461                        }
1462
1463                        debug(500, "fetype=%d, orbitalpos=%d, frequ=%d, inverion=%d, symbolrate=%d, polarization=%d, fec=%d, modulation=%d, rolloff=%d, pilot=%d, system=%d", fenode->feinfo->type, orbitalpos, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, system);
1464                        tpnode = createtransponder(99, fenode->feinfo->type, orbitalpos, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, system);
1465                }
1466                if(tpnode != NULL)
1467                {
1468                        tpmax = 1;
1469                        satnode = getsatbyorbitalpos(tpnode->orbitalpos);
1470                        if(satnode != NULL) satnode->scan = 1;
1471                }
1472        }
1473        else if(scantype == 1) //single sat
1474        {
1475                if(clear == 1) delchannelbysat(orbitalpos);
1476                tpnode = transponder;
1477                while(tpnode != NULL)
1478                {
1479                        if(tpnode->orbitalpos == orbitalpos)
1480                                tpmax++;
1481                        tpnode = tpnode->next;
1482                }
1483                tpnode = transponder;
1484                satnode = getsatbyorbitalpos(orbitalpos);
1485                if(satnode != NULL) satnode->scan = 1;
1486        }
1487        else if(scantype == 2 || scantype == 3) //2: multi sat, 3: all
1488        {
1489                if(scantype == 2)
1490                {
1491                        scansetmultisat(mscan);
1492                        if(clear == 1) delchannelbymultisat();
1493                }
1494                if(scantype == 3)
1495                {
1496                        scansetallsat(-1);
1497                        b2->hidden = YES;
1498                        b3->hidden = YES;
1499                        //del all channel for auto. search
1500                        if(clear == 1) freechannel(1);
1501                }
1502                satnode = sat;
1503                while(satnode != NULL)
1504                {
1505                        if(satnode->scan != 0)
1506                        {
1507                                tpnode = transponder;
1508                                while(tpnode != NULL)
1509                                {
1510                                        if(tpnode->orbitalpos == satnode->orbitalpos)
1511                                                tpmax++;
1512                                        tpnode = tpnode->next;
1513                                }
1514                        }
1515                        satnode = satnode->next;
1516                }
1517                tpnode = transponder;
1518        }
1519
1520        scaninfo.fenode = fenode;
1521        scaninfo.tpnode = tpnode;
1522        scaninfo.scanscreen = scan;
1523        scaninfo.listbox = listbox;
1524        scaninfo.timeout = timeout;
1525        scaninfo.scantype = scantype;
1526        scaninfo.orbitalpos = orbitalpos;
1527        scaninfo.onlyfree = onlyfree;
1528        scaninfo.networkscan = networkscan;
1529        scaninfo.blindscan = blindscan;
1530        scaninfo.changename = ichangename;
1531        scaninfo.clear = clear;
1532        scaninfo.tpmax = tpmax;
1533        timernode = addtimer(&doscan, START, 1000, 1, NULL, NULL, NULL);
1534
1535        while(1)
1536        {
1537                //satname
1538                tmpstr = ostrcat(tmpstr, _("Sat/Provider: "), 1, 0);
1539                tmpstr = ostrcat(tmpstr, scaninfo.satname, 1, 0);
1540                changetext(satname, tmpstr);
1541                free(tmpstr); tmpstr = NULL;
1542
1543                //transpondercount
1544                tmpstr = ostrcat(tmpstr, _("Transponder: "), 1, 0);
1545                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.tpcount), 1, 1);
1546                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1547                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.tpmax), 1, 1);
1548                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1549                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.tpnew), 1, 1);
1550                changetext(tpcount, tmpstr);
1551                free(tmpstr); tmpstr = NULL;
1552
1553                //tvcount
1554                tmpstr = ostrcat(tmpstr, _("TV: "), 1, 0);
1555                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.newtvcount), 1, 1);
1556                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1557                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.tvcount), 1, 1);
1558                changetext(foundtv, tmpstr);
1559                free(tmpstr); tmpstr = NULL;
1560
1561                //radiocount
1562                tmpstr = ostrcat(tmpstr, _("Radio: "), 1, 0);
1563                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.newradiocount), 1, 1);
1564                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1565                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.radiocount), 1, 1);
1566                changetext(foundradio, tmpstr);
1567                free(tmpstr); tmpstr = NULL;
1568
1569                //datacount
1570                tmpstr = ostrcat(tmpstr, _("Data: "), 1, 0);
1571                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.newdatacount), 1, 1);
1572                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1573                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.datacount), 1, 1);
1574                changetext(founddata, tmpstr);
1575                free(tmpstr); tmpstr = NULL;
1576
1577                //blindcount
1578                tmpstr = ostrcat(tmpstr, _("Blindscan: "), 1, 0);
1579                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.newblindcount), 1, 1);
1580                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1581                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.blindcount), 1, 1);
1582                tmpstr = ostrcat(tmpstr, " / ", 1, 0);
1583                tmpstr = ostrcat(tmpstr, oitoa(scaninfo.blindmax), 1, 1);
1584                changetext(foundblind, tmpstr);
1585                free(tmpstr); tmpstr = NULL;
1586
1587                if(scaninfo.tpmax == 0)
1588                        progress->progresssize = 100;
1589                else
1590                        progress->progresssize = (100 / (float)scaninfo.tpmax) * scaninfo.tpcount;
1591
1592                drawscreen(scan, 0, 0);
1593                rcret = waitrc(scan, 1000, 0);
1594
1595                if(scantype != 3 && rcret == getrcconfigint("rcred", NULL))
1596                        scanaddchannel(listbox->select, scantype, tpnode, ichangename);
1597
1598                if((scantype != 3 && rcret == getrcconfigint("rcgreen", NULL)) || (scantype == 3 && scaninfo.threadend == 1 && alladded < 2))
1599                {
1600                        struct skin* lnode = listbox;
1601
1602                        long deaktivcol = convertcol("deaktivcol");
1603                        if(scantype == 3 && alladded == 0)
1604                        {
1605                                alladded = 1;
1606                                continue;
1607                        }
1608                        alladded = 2;
1609
1610                        drawscreen(load, 0, 0);
1611                        while(lnode != NULL)
1612                        {
1613                                if(lnode->fontcol != deaktivcol && lnode->del == 1)
1614                                        scanaddchannel(lnode, scantype, tpnode, ichangename);
1615                                lnode = lnode->next;
1616                        }
1617                        clearscreen(load);
1618                        textbox(_("Message"), _("All new channels added!"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1619                }
1620
1621                if(rcret == getrcconfigint("rcexit", NULL))
1622                {
1623                        if(timernode != NULL && scaninfo.threadend == 0)
1624                        {
1625                                timernode->aktion = STOP;
1626                                while(i < 4 && scaninfo.threadend == 0)
1627                                {
1628                                        textbox(_("Message"), _("Wait for channel scan end"), NULL, 0, NULL, 0, NULL, 0, NULL, 0, 600, 200, 3, 0);
1629                                        i++;
1630                                }
1631                        }
1632                        break;
1633                }
1634        }
1635
1636        if(scantype == 0) deltransponderbyid(99);
1637        if(clear == 1)
1638        {
1639                if(textbox(_("Message"), _("Do you want to delete all unused Bouquetentrys?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0) == 1)
1640                        delunusedbouquetchannels(0);
1641                else
1642                        delunusedbouquetchannels(1);
1643        }
1644        delmarkedscreennodes(scan, 1);
1645        delownerrc(scan);
1646        clearscreen(scan);
1647        resetsatscan();
1648        drawscreen(load, 0, 0);
1649  sortchannel();
1650  clearscreen(load);
1651}
1652
1653void changescantype(char* scantype, struct skin* scan, struct skin* listbox, struct skin* tuner, struct skin* satellite, struct skin* id, struct skin* system, struct skin* frequency, struct skin* inversion, struct skin* symbolrate, struct skin* polarization, struct skin* fec, struct skin* modulation, struct skin* rolloff, struct skin* pilot, struct skin* hp, struct skin* lp, struct skin* bandwidth, struct skin* transmission, struct skin* guardinterval, struct skin* hierarchy, struct skin* b4, struct skin* b5, int flag)
1654{
1655        struct sat* satnode = sat;
1656        struct skin* tmp = NULL;
1657        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpnr = NULL;
1658        char* feshortname = NULL;
1659        int i, orbitalpos = 0;
1660
1661        if(tuner != NULL) feshortname = tuner->ret;
1662
1663        tuner->hidden = NO;
1664        id->hidden = NO;
1665        system->hidden = NO;
1666        frequency->hidden = NO;
1667        inversion->hidden = NO;
1668        symbolrate->hidden = NO;
1669        polarization->hidden = NO;
1670        fec->hidden = NO;
1671        modulation->hidden = NO;
1672        rolloff->hidden = NO;
1673        pilot->hidden = NO;
1674        hp->hidden = NO;
1675        lp->hidden = NO;
1676        bandwidth->hidden = NO;
1677        transmission->hidden = NO;
1678        guardinterval->hidden = NO;
1679        hierarchy->hidden = NO;
1680        satellite->hidden = NO;
1681        b4->hidden = NO;
1682        b5->hidden = NO;
1683        delmarkedscreennodes(scan, 1);
1684
1685        if(flag == 0 && ostrcmp(scantype, "0") == 0 && ostrcmp(system->ret, "0") == 0)
1686        {
1687                modulation->hidden = YES;
1688                rolloff->hidden = YES;
1689                pilot->hidden = YES;
1690        }
1691
1692        if(ostrcmp(scantype, "1") == 0 || ostrcmp(scantype, "2") == 0 || ostrcmp(scantype, "3") == 0)
1693        {
1694                id->hidden = YES;
1695                system->hidden = YES;
1696                frequency->hidden = YES;
1697                inversion->hidden = YES;
1698                symbolrate->hidden = YES;
1699                polarization->hidden = YES;
1700                fec->hidden = YES;
1701                modulation->hidden = YES;
1702                rolloff->hidden = YES;
1703                pilot->hidden = YES;
1704                hp->hidden = YES;
1705                lp->hidden = YES;
1706                bandwidth->hidden = YES;
1707                transmission->hidden = YES;
1708                guardinterval->hidden = YES;
1709                hierarchy->hidden = YES;
1710                b4->hidden = YES;
1711                b5->hidden = YES;
1712        }
1713        if(ostrcmp(scantype, "2") == 0 && feshortname != NULL)
1714        {
1715                satellite->hidden = YES;
1716
1717                tmpstr = ostrcat(feshortname, "_sat", 0, 0);
1718                for(i = 1; i <= getmaxsat(feshortname); i++)
1719                {
1720                        tmpnr = oitoa(i);
1721                        orbitalpos = getconfigint(tmpstr, tmpnr);
1722                        free(tmpnr); tmpnr = NULL;
1723
1724                        satnode = getsatbyorbitalpos(orbitalpos);
1725                        if(satnode != NULL && satnode->fetype == FE_QPSK)
1726                        {
1727                                tmp = addlistbox(scan, listbox, tmp, 1);
1728                                if(tmp != NULL)
1729                                {
1730                                        tmpstr1 = oitoa(satnode->orbitalpos);
1731                                        changename(tmp, tmpstr1);
1732                                        free(tmpstr1); tmpstr1 = NULL;
1733                                        changetext(tmp, satnode->name);
1734                                        tmp->type = CHOICEBOX;
1735                                        addchoicebox(tmp, "0", _("no"));
1736                                        addchoicebox(tmp, "1", _("yes"));
1737                                }
1738                        }
1739                }
1740                free(tmpstr); tmpstr = NULL;
1741        }
1742        if(ostrcmp(scantype, "3") == 0)
1743        {
1744                tuner->hidden = YES;
1745                satellite->hidden = YES;
1746        }
1747
1748        if(flag == 2)
1749        {
1750                system->hidden = YES;
1751                inversion->hidden = YES;
1752                polarization->hidden = YES;
1753                rolloff->hidden = YES;
1754                pilot->hidden = YES;
1755                satellite->hidden = YES;
1756        }
1757
1758        if(flag == 3)
1759        {
1760                system->hidden = YES;
1761                polarization->hidden = YES;
1762                rolloff->hidden = YES;
1763                pilot->hidden = YES;
1764                satellite->hidden = YES;
1765                symbolrate->hidden = YES;
1766                fec->hidden = YES;
1767        }
1768        else
1769        {
1770                hp->hidden = YES;
1771                lp->hidden = YES;
1772                bandwidth->hidden = YES;
1773                transmission->hidden = YES;
1774                guardinterval->hidden = YES;
1775                hierarchy->hidden = YES;
1776        }
1777}
1778
1779void scanchangesat(struct skin* sat, struct transponder* tpnode, char* feshortname)
1780{
1781        char* tmpstr = NULL;
1782
1783        changeinput(sat, NULL);
1784        changechoiceboxvalue(sat, NULL);
1785        tmpstr = getsatstring(feshortname, FE_QPSK);
1786        changeinput(sat, tmpstr);
1787        free(tmpstr); tmpstr = NULL;
1788        tmpstr = getorbitalposstring(feshortname, FE_QPSK);
1789        changechoiceboxvalue(sat, tmpstr);
1790        free(tmpstr); tmpstr = NULL;
1791        if(tpnode != NULL)
1792        {
1793                tmpstr = oitoa(tpnode->orbitalpos);
1794                setchoiceboxselection(sat, tmpstr);
1795                free(tmpstr); tmpstr = NULL;
1796        }
1797}
1798
1799//flag 0: manual scan (DVB-S)
1800//flag 1: auto scan (all)
1801//flag 2: manual scan (DVB-C)
1802//flag 3: manual scan (DVB-T)
1803void screenscanconfig(int flag)
1804{
1805        int rcret = 0, fetype = -1;
1806        unsigned int ifrequency = -1, isymbolrate = -1;
1807        int iscantype = -1, isat = -1;
1808        int iinversion = -1, ipolarization = -1;
1809        int ifec = -1, imodulation = -1, irolloff = -1, ipilot = -1, isystem = -1;
1810        int inetworkscan = -1, ionlyfree = -1, iclear = -1, iblindscan = -1, ichangename = -1;
1811        int i = 0, treffer = 0, tunercount = 0;
1812        struct skin* scan = getscreen("manualscan");
1813        struct skin* listbox = getscreennode(scan, "listbox");
1814        struct skin* tuner = getscreennode(scan, "tuner");
1815        struct skin* scantype = getscreennode(scan, "scantype");
1816        struct skin* sat = getscreennode(scan, "sat");
1817        struct skin* id = getscreennode(scan, "id");
1818        struct skin* system = getscreennode(scan, "system");
1819        struct skin* frequency = getscreennode(scan, "frequency");
1820        struct skin* inversion = getscreennode(scan, "inversion");
1821        struct skin* symbolrate = getscreennode(scan, "symbolrate");
1822        struct skin* polarization = getscreennode(scan, "polarization");
1823        struct skin* fec = getscreennode(scan, "fec");
1824        struct skin* modulation = getscreennode(scan, "modulation");
1825        struct skin* rolloff = getscreennode(scan, "rolloff");
1826        struct skin* pilot = getscreennode(scan, "pilot");
1827        struct skin* hp = getscreennode(scan, "hp");
1828        struct skin* lp = getscreennode(scan, "lp");
1829        struct skin* bandwidth = getscreennode(scan, "bandwidth");
1830        struct skin* transmission = getscreennode(scan, "transmission");
1831        struct skin* guardinterval = getscreennode(scan, "guardinterval");
1832        struct skin* hierarchy = getscreennode(scan, "hierarchy");
1833        struct skin* networkscan = getscreennode(scan, "networkscan");
1834        struct skin* clear = getscreennode(scan, "clear");
1835        struct skin* onlyfree = getscreennode(scan, "onlyfree");
1836        struct skin* blindscan = getscreennode(scan, "blindscan");
1837        struct skin* changename = getscreennode(scan, "changename");
1838        struct skin* b4 = getscreennode(scan, "b4");
1839        struct skin* b5 = getscreennode(scan, "b5");
1840        struct skin* tmp = NULL;
1841        char* tmpstr = NULL, *tmpnr = NULL, *feshortname = NULL;
1842        struct transponder* tpnode = NULL;
1843        struct dvbdev* dvbnode = dvbdev;
1844       
1845        listbox->aktline = 1;
1846        listbox->aktpage = -1;
1847
1848        if(status.recording > 0 || status.streaming > 0)
1849        {
1850                textbox(_("Message"), _("Scan is not allowed if record\nor stream is running !"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1851                return;
1852        }
1853
1854        //del old values
1855        changeinput(tuner, NULL);
1856        changechoiceboxvalue(tuner, NULL);
1857        changeinput(scantype, NULL);
1858        changechoiceboxvalue(scantype, NULL);
1859        changeinput(sat, NULL);
1860        changechoiceboxvalue(sat, NULL);
1861        changeinput(system, NULL);
1862        changechoiceboxvalue(system, NULL);
1863        changeinput(inversion, NULL);
1864        changechoiceboxvalue(inversion, NULL);
1865        changeinput(polarization, NULL);
1866        changechoiceboxvalue(polarization, NULL);
1867        changeinput(fec, NULL);
1868        changechoiceboxvalue(fec, NULL);
1869        changeinput(modulation, NULL);
1870        changechoiceboxvalue(modulation, NULL);
1871        changeinput(rolloff, NULL);
1872        changechoiceboxvalue(rolloff, NULL);
1873        changeinput(pilot, NULL);
1874        changechoiceboxvalue(pilot, NULL);
1875        changeinput(hp, NULL);
1876        changeinput(lp, NULL);
1877        changeinput(bandwidth, NULL);
1878        changeinput(transmission, NULL);
1879        changeinput(guardinterval, NULL);
1880        changeinput(hierarchy, NULL);
1881        changechoiceboxvalue(hp, NULL);
1882        changechoiceboxvalue(lp, NULL);
1883        changechoiceboxvalue(bandwidth, NULL);
1884        changechoiceboxvalue(transmission, NULL);
1885        changechoiceboxvalue(guardinterval, NULL);
1886        changechoiceboxvalue(hierarchy, NULL);
1887
1888        frequency->aktpage = 0;
1889        symbolrate->aktpage = 0;
1890
1891        if(flag == 0) fetype = FE_QPSK;
1892        if(flag == 2) fetype = FE_QAM;
1893        if(flag == 3) fetype = FE_OFDM;
1894
1895        //tuner
1896        while(dvbnode != NULL)
1897        {
1898                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo != NULL && dvbnode->felock < 1 && (flag == 1 || dvbnode->feinfo->type == fetype))
1899                {
1900                        treffer = 0;
1901                        if(dvbnode->feshortname != NULL)
1902                        {
1903                                tmpstr = ostrcat(dvbnode->feshortname, "_sat", 0, 0);
1904                                for(i = 1; i <= getmaxsat(dvbnode->feshortname); i++)
1905                                {
1906                                        tmpnr = oitoa(i);
1907                                        if(getconfigint(tmpstr, tmpnr) != 0)
1908                                        {
1909                                                treffer = 1;
1910                                                break;
1911                                        }
1912                                        free(tmpnr); tmpnr = NULL;
1913                                }
1914                                free(tmpnr); tmpnr = NULL;
1915                                free(tmpstr); tmpstr = NULL;
1916                        }
1917
1918                        if(treffer == 0)
1919                        {
1920                                dvbnode = dvbnode->next;
1921                                continue;
1922                        }
1923
1924                        tunercount++;
1925                        if(feshortname == NULL) feshortname = dvbnode->feshortname;
1926
1927                        tmpstr = ostrcat(tmpstr, dvbnode->feinfo->name, 1, 0);
1928                        tmpstr = ostrcat(tmpstr, " (", 1, 0);
1929                        tmpstr = ostrcat(tmpstr, oitoa(dvbnode->adapter), 1, 1);
1930                        tmpstr = ostrcat(tmpstr, "/", 1, 0);
1931                        tmpstr = ostrcat(tmpstr, oitoa(dvbnode->devnr), 1, 1);
1932                        tmpstr = ostrcat(tmpstr, ")", 1, 0);
1933                        addchoicebox(tuner, dvbnode->feshortname, tmpstr);
1934                        free(tmpstr); tmpstr = NULL;
1935                }
1936                dvbnode = dvbnode->next;
1937        }
1938
1939        if(tunercount < 1)
1940        {
1941                textbox(_("Message"), _("No Tuner configured"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1942                return;
1943        }
1944
1945        rcret = servicestop(status.aktservice, 1, 1);
1946        if(rcret == 1) return;
1947
1948        if(status.aktservice->channel != NULL)
1949                tpnode = status.aktservice->channel->transponder;
1950
1951start:
1952
1953        if(flag == 0)
1954        {
1955                addchoicebox(scantype, "0", _("Single Transponder"));
1956                addchoicebox(scantype, "1", _("Single Sat"));
1957                addchoicebox(scantype, "2", _("Multi Sat"));
1958                setchoiceboxselection(scantype, "0");
1959        }
1960        else if(flag == 2 || flag == 3)
1961        {
1962                addchoicebox(scantype, "0", _("Single Transponder"));
1963                addchoicebox(scantype, "1", _("Single Provider"));
1964                setchoiceboxselection(scantype, "0");
1965        }
1966        else
1967        {
1968                addchoicebox(scantype, "3", _("Auto Scan"));
1969                setchoiceboxselection(scantype, "3");
1970        }
1971
1972        //sat
1973        scanchangesat(sat, tpnode, feshortname);
1974
1975        //id
1976        if(tpnode != NULL)
1977                tmpstr = ollutoa(tpnode->id);
1978        changeinput(id, tmpstr);
1979        free(tmpstr); tmpstr = NULL;
1980
1981        //system
1982        tmpstr = transpondergetsystemstr(tpnode, 1);
1983        changeinput(system, tmpstr);
1984        free(tmpstr); tmpstr = NULL;
1985        tmpstr = transpondergetsystemstr(tpnode, 2);
1986        changechoiceboxvalue(system, tmpstr);
1987        free(tmpstr); tmpstr = NULL;
1988        if(tpnode != NULL)
1989        {
1990                tmpstr = oitoa(tpnode->system);
1991                setchoiceboxselection(system, tmpstr);
1992                free(tmpstr); tmpstr = NULL;
1993        }
1994
1995        //frequency
1996        if(tpnode != NULL)
1997                tmpstr = oitoa(tpnode->frequency / 1000);
1998        else
1999        {
2000                if(flag == 3)
2001                        tmpstr = ostrcat(tmpstr, "000000", 1, 0);
2002                else
2003                        tmpstr = ostrcat(tmpstr, "00000", 1, 0);
2004        }
2005        if(flag == 2 || flag == 3)
2006        {
2007                changemask(frequency, "000000");
2008                changeinput(frequency, tmpstr);
2009                frequency->input = mask(frequency->input, 6, "0");
2010        }
2011        else
2012        {
2013                changemask(frequency, "00000");
2014                changeinput(frequency, tmpstr);
2015                frequency->input = mask(frequency->input, 5, "0");
2016        }
2017        free(tmpstr); tmpstr = NULL;
2018
2019        //inversion
2020        tmpstr = transpondergetinversionstr(tpnode, 1);
2021        changeinput(inversion, tmpstr);
2022        free(tmpstr); tmpstr = NULL;
2023        tmpstr = transpondergetinversionstr(tpnode, 2);
2024        changechoiceboxvalue(inversion, tmpstr);
2025        free(tmpstr); tmpstr = NULL;
2026        if(tpnode != NULL)
2027        {
2028                tmpstr = oitoa(tpnode->inversion);
2029                setchoiceboxselection(inversion, tmpstr);
2030                free(tmpstr); tmpstr = NULL;
2031        }
2032
2033        //symbolrate
2034        if(tpnode != NULL)
2035                tmpstr = oitoa(tpnode->symbolrate / 1000);
2036        else
2037                tmpstr = ostrcat(tmpstr, "00000", 1, 0);
2038        changemask(symbolrate, "00000");
2039        changeinput(symbolrate, tmpstr);
2040        symbolrate->input = mask(symbolrate->input, 5, "0");
2041        free(tmpstr); tmpstr = NULL;
2042
2043        //polarization
2044        tmpstr = transpondergetpolarizationstr(tpnode, 1);
2045        changeinput(polarization, tmpstr);
2046        free(tmpstr); tmpstr = NULL;
2047        tmpstr = transpondergetpolarizationstr(tpnode, 2);
2048        changechoiceboxvalue(polarization, tmpstr);
2049        free(tmpstr); tmpstr = NULL;
2050        if(tpnode != NULL)
2051        {
2052                tmpstr = oitoa(tpnode->polarization);
2053                setchoiceboxselection(polarization, tmpstr);
2054                free(tmpstr); tmpstr = NULL;
2055        }
2056
2057        //fec
2058        tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2059        changeinput(fec, tmpstr);
2060        free(tmpstr); tmpstr = NULL;
2061        tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2062        changechoiceboxvalue(fec, tmpstr);
2063        free(tmpstr); tmpstr = NULL;
2064        if(tpnode != NULL)
2065        {
2066                tmpstr = oitoa(tpnode->fec);
2067                setchoiceboxselection(fec, tmpstr);
2068                free(tmpstr); tmpstr = NULL;
2069        }
2070
2071        //modulation
2072        tmpstr = transpondergetmodulationstr(tpnode, fetype, 1);
2073        changeinput(modulation, tmpstr);
2074        free(tmpstr); tmpstr = NULL;
2075        tmpstr = transpondergetmodulationstr(tpnode, fetype, 2);
2076        changechoiceboxvalue(modulation, tmpstr);
2077        free(tmpstr); tmpstr = NULL;
2078        if(tpnode != NULL)
2079        {
2080                tmpstr = oitoa(tpnode->modulation);
2081                setchoiceboxselection(modulation, tmpstr);
2082                free(tmpstr); tmpstr = NULL;
2083        }
2084
2085        //rolloff
2086        tmpstr = transpondergetrolloffstr(tpnode, 1);
2087        changeinput(rolloff, tmpstr);
2088        free(tmpstr); tmpstr = NULL;
2089        tmpstr = transpondergetrolloffstr(tpnode, 2);
2090        changechoiceboxvalue(rolloff, tmpstr);
2091        free(tmpstr); tmpstr = NULL;
2092        if(tpnode != NULL)
2093        {
2094                tmpstr = oitoa(tpnode->rolloff);
2095                setchoiceboxselection(rolloff, tmpstr);
2096                free(tmpstr); tmpstr = NULL;
2097        }
2098
2099        //pilot
2100        tmpstr = transpondergetpilotstr(tpnode, 1);
2101        changeinput(pilot, tmpstr);
2102        free(tmpstr); tmpstr = NULL;
2103        tmpstr = transpondergetpilotstr(tpnode, 2);
2104        changechoiceboxvalue(pilot, tmpstr);
2105        free(tmpstr); tmpstr = NULL;
2106        if(tpnode != NULL)
2107        {
2108                tmpstr = oitoa(tpnode->pilot);
2109                setchoiceboxselection(pilot, tmpstr);
2110                free(tmpstr); tmpstr = NULL;
2111        }
2112
2113        //hp
2114        tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2115        changeinput(hp, tmpstr);
2116        free(tmpstr); tmpstr = NULL;
2117        tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2118        changechoiceboxvalue(hp, tmpstr);
2119        free(tmpstr); tmpstr = NULL;
2120        if(tpnode != NULL)
2121        {
2122                tmpstr = oitoa(tpnode->fec);
2123                setchoiceboxselection(hp, tmpstr);
2124                free(tmpstr); tmpstr = NULL;
2125        }
2126
2127        //lp
2128        tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2129        changeinput(lp, tmpstr);
2130        free(tmpstr); tmpstr = NULL;
2131        tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2132        changechoiceboxvalue(lp, tmpstr);
2133        free(tmpstr); tmpstr = NULL;
2134        if(tpnode != NULL)
2135        {
2136                tmpstr = oitoa(tpnode->polarization);
2137                setchoiceboxselection(lp, tmpstr);
2138                free(tmpstr); tmpstr = NULL;
2139        }
2140
2141        //bandwidth
2142        tmpstr = transpondergetbandwidthstr(tpnode, 1);
2143        changeinput(bandwidth, tmpstr);
2144        free(tmpstr); tmpstr = NULL;
2145        tmpstr = transpondergetbandwidthstr(tpnode, 2);
2146        changechoiceboxvalue(bandwidth, tmpstr);
2147        free(tmpstr); tmpstr = NULL;
2148        if(tpnode != NULL)
2149        {
2150                tmpstr = oitoa(tpnode->symbolrate);
2151                setchoiceboxselection(bandwidth, tmpstr);
2152                free(tmpstr); tmpstr = NULL;
2153        }
2154
2155        //guardinterval
2156        tmpstr = transpondergetguardintervalstr(tpnode, 1);
2157        changeinput(guardinterval, tmpstr);
2158        free(tmpstr); tmpstr = NULL;
2159        tmpstr = transpondergetguardintervalstr(tpnode, 2);
2160        changechoiceboxvalue(guardinterval, tmpstr);
2161        free(tmpstr); tmpstr = NULL;
2162        if(tpnode != NULL)
2163        {
2164                tmpstr = oitoa(tpnode->rolloff);
2165                setchoiceboxselection(guardinterval, tmpstr);
2166                free(tmpstr); tmpstr = NULL;
2167        }
2168
2169        //transmission
2170        tmpstr = transpondergettransmissionstr(tpnode, 1);
2171        changeinput(transmission, tmpstr);
2172        free(tmpstr); tmpstr = NULL;
2173        tmpstr = transpondergettransmissionstr(tpnode, 2);
2174        changechoiceboxvalue(transmission, tmpstr);
2175        free(tmpstr); tmpstr = NULL;
2176        if(tpnode != NULL)
2177        {
2178                tmpstr = oitoa(tpnode->pilot);
2179                setchoiceboxselection(transmission, tmpstr);
2180                free(tmpstr); tmpstr = NULL;
2181        }
2182
2183        //hierarchy
2184        tmpstr = transpondergethierarchystr(tpnode, 1);
2185        changeinput(hierarchy, tmpstr);
2186        free(tmpstr); tmpstr = NULL;
2187        tmpstr = transpondergethierarchystr(tpnode, 2);
2188        changechoiceboxvalue(hierarchy, tmpstr);
2189        free(tmpstr); tmpstr = NULL;
2190        if(tpnode != NULL)
2191        {
2192                tmpstr = oitoa(tpnode->system);
2193                setchoiceboxselection(hierarchy, tmpstr);
2194                free(tmpstr); tmpstr = NULL;
2195        }
2196
2197        //networkscan
2198        addchoicebox(networkscan, "0", _("no"));
2199        addchoicebox(networkscan, "1", _("yes"));
2200
2201        //clear
2202        addchoicebox(clear, "0", _("no"));
2203        addchoicebox(clear, "1", _("yes"));
2204
2205        //only free
2206        addchoicebox(onlyfree, "0", _("no"));
2207        addchoicebox(onlyfree, "1", _("yes"));
2208
2209        //blindscan
2210        addchoicebox(blindscan, "0", _("no"));
2211        addchoicebox(blindscan, "1", _("yes"));
2212
2213        //changename
2214        addchoicebox(changename, "0", _("no"));
2215        addchoicebox(changename, "1", _("yes"));
2216
2217        drawscreen(scan, 2, 0);
2218        changescantype(scantype->ret, scan, listbox, tuner, sat, id, system, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, hp, lp, bandwidth, transmission, guardinterval, hierarchy, b4, b5, flag);
2219        drawscreen(scan, 0, 0);
2220        addscreenrc(scan, listbox);
2221
2222        tmp = listbox->select;
2223        while(1)
2224        {
2225                addscreenrc(scan, tmp);
2226                rcret = waitrc(scan, 0, 0);
2227                tmp = listbox->select;
2228
2229                if(scantype->ret != NULL) iscantype = atoi(scantype->ret);
2230                if(sat->ret != NULL) isat = atoi(sat->ret);
2231                if(system->ret != NULL) isystem = atoi(system->ret);
2232                if(frequency->ret != NULL) ifrequency = atoi(frequency->ret) * 1000;
2233                if(inversion->ret != NULL) iinversion = atoi(inversion->ret);
2234                if(symbolrate->ret != NULL) isymbolrate = atoi(symbolrate->ret) * 1000;
2235                if(polarization->ret != NULL) ipolarization = atoi(polarization->ret);
2236                if(fec->ret != NULL) ifec = atoi(fec->ret);
2237                if(modulation->ret != NULL) imodulation = atoi(modulation->ret);
2238                if(rolloff->ret != NULL) irolloff = atoi(rolloff->ret);
2239                if(pilot->ret != NULL) ipilot = atoi(pilot->ret);
2240
2241                if(flag == 3)
2242                {
2243                        if(hp->ret != NULL) ifec = atoi(hp->ret);
2244                        if(lp->ret != NULL) ipolarization = atoi(lp->ret);
2245                        if(bandwidth->ret != NULL) isymbolrate = atoi(bandwidth->ret);
2246                        if(transmission->ret != NULL) ipilot = atoi(transmission->ret);
2247                        if(guardinterval->ret != NULL) irolloff = atoi(guardinterval->ret);
2248                        if(hierarchy->ret != NULL) isystem = atoi(hierarchy->ret);
2249                }
2250
2251                if(networkscan->ret != NULL) inetworkscan = atoi(networkscan->ret);
2252                if(onlyfree->ret != NULL) ionlyfree = atoi(onlyfree->ret);
2253                if(clear->ret != NULL) iclear = atoi(clear->ret);
2254                if(blindscan->ret != NULL) iblindscan = atoi(blindscan->ret);
2255                if(changename->ret != NULL) ichangename = atoi(changename->ret);
2256
2257                if(rcret == getrcconfigint("rcexit", NULL)) break;
2258                if(rcret == getrcconfigint("rcok", NULL)) break;
2259                if(listbox->select != NULL && ostrcmp(listbox->select->name, "tuner") == 0)
2260                {
2261                        scanchangesat(sat, tpnode, listbox->select->ret);
2262                        changescantype(scantype->ret, scan, listbox, tuner, sat, id, system, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, hp, lp, bandwidth, transmission, guardinterval, hierarchy, b4, b5, flag);
2263                        drawscreen(scan, 0, 0);
2264                }
2265                if(listbox->select != NULL && ostrcmp(listbox->select->name, "scantype") == 0)
2266                {
2267                        changescantype(scantype->ret, scan, listbox, tuner, sat, id, system, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, hp, lp, bandwidth, transmission, guardinterval, hierarchy, b4, b5, flag);
2268                        drawscreen(scan, 0, 0);
2269                }
2270                if(listbox->select != NULL && ostrcmp(listbox->select->name, "system") == 0)
2271                {
2272                        changescantype(scantype->ret, scan, listbox, tuner, sat, id, system, frequency, inversion, symbolrate, polarization, fec, modulation, rolloff, pilot, hp, lp, bandwidth, transmission, guardinterval, hierarchy, b4, b5, flag);
2273                        drawscreen(scan, 0, 0);
2274                }
2275                if(rcret == getrcconfigint("rcred", NULL))
2276                {
2277                        clearscreen(scan);
2278                        screenscan(tpnode, scan->child, tuner->ret, iscantype, isat, ifrequency, iinversion, isymbolrate, ipolarization, ifec, imodulation, irolloff, ipilot, inetworkscan, ionlyfree, iclear, iblindscan, ichangename, isystem, 5000000);
2279                        drawscreen(scan, 0, 0);
2280                }
2281                if(rcret == getrcconfigint("rcgreen", NULL) && tpnode != NULL && iscantype == 0)
2282                {
2283                        struct transponder* tp1 = createtransponder(99, tpnode->fetype, isat, ifrequency, iinversion, isymbolrate, ipolarization, ifec, imodulation, irolloff, ipilot, isystem);
2284                        copytransponder(tp1, tpnode, 99);
2285                        deltransponderbyid(99);
2286                        textbox(_("Message"), _("Transponder changed"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
2287                        drawscreen(scan, 0, 0);
2288                }
2289                if(rcret == getrcconfigint("rcyellow", NULL) && iscantype == 0)
2290                {
2291                        struct transponder* tp = tpchoicescreen(isat, flag);
2292                        if(tp != NULL)
2293                        {
2294                                tpnode = tp;
2295                                goto start;
2296                        }
2297                        else
2298                                drawscreen(scan, 0, 0);
2299                }
2300                else if(rcret == getrcconfigint("rcok", NULL))
2301                        break;
2302        }
2303
2304        delmarkedscreennodes(scan, 1);
2305        delownerrc(scan);
2306        clearscreen(scan);
2307        resetsatscan();
2308
2309        if(status.lastservice->channel == NULL)
2310        {
2311                if(status.servicetype == 0)
2312                        servicecheckret(servicestart(getchannel(getconfigint("serviceid", NULL), getconfigllu("transponderid", NULL)), getconfig("channellist", NULL), NULL, 0), 0);
2313                else
2314                        servicecheckret(servicestart(getchannel(getconfigint("rserviceid", NULL), getconfigllu("rtransponderid", NULL)), getconfig("rchannellist", NULL),  NULL, 0), 0);
2315        }
2316        else
2317        {
2318                tmpstr = ostrcat(status.lastservice->channellist, NULL, 0, 0);
2319                servicecheckret(servicestart(status.lastservice->channel, tmpstr, NULL, 0), 0);
2320                free(tmpstr); tmpstr = NULL;
2321        }
2322
2323        //recalc channels
2324        struct channel* chnode = channel;
2325        while(chnode != NULL)
2326        {
2327                if(chnode->servicetype != 99)
2328                {
2329                        chnode->transponder = gettransponder(chnode->transponderid);
2330                        chnode->provider = getprovider(chnode->providerid);
2331                }
2332                chnode = chnode->next;
2333        }
2334       
2335        writeallconfig(1);
2336}
2337
2338#endif
Note: See TracBrowser for help on using the repository browser.