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