Context Navigation

source: titan/titan/scan.h @ 24240

Last change on this file since 24240 was 24240, checked in by nit, 10 years ago
[titan] add message after scan
File size: 67.0 KB

Line
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	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
216	struct 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
316	int 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
423	int 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
580	uint64_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
602	unsigned 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
766	unsigned 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
906	unsigned 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
1045	void 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
1057	void 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	if(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
1237	void 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
1314	void 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 && dvbnode->deactive == 0 && (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
1343	void 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
1360	void 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
1383	void 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
1395	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 favtype, int emptybouquet, int unusedbouquetchannels, int timeout)
1396	{
1397	int rcret = 0, tpmax = 0, i = 0, alladded = 0, endmsgshow = 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 && scaninfo.threadend == 1 && endmsgshow == 0)
1596	{
1597	textbox(_("Message"), _("Channel scan ended.\nYou can add all channel (green) or\neach and every (red) to the channellist."), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1598	endmsgshow = 1;
1599	}
1600
1601	if(scantype != 3 && rcret == getrcconfigint("rcred", NULL))
1602	scanaddchannel(listbox->select, scantype, tpnode, ichangename);
1603
1604	if((scantype != 3 && rcret == getrcconfigint("rcgreen", NULL)) \|\| (scantype == 3 && scaninfo.threadend == 1 && alladded < 2))
1605	{
1606	struct skin* lnode = listbox;
1607
1608	long deaktivcol = convertcol("deaktivcol");
1609	if(scantype == 3 && alladded == 0)
1610	{
1611	alladded = 1;
1612	continue;
1613	}
1614	alladded = 2;
1615
1616	drawscreen(load, 0, 0);
1617	while(lnode != NULL)
1618	{
1619	if(lnode->fontcol != deaktivcol && lnode->del == 1)
1620	scanaddchannel(lnode, scantype, tpnode, ichangename);
1621	lnode = lnode->next;
1622	}
1623	clearscreen(load);
1624	textbox(_("Message"), _("All new channels added!"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1625	}
1626
1627	if(rcret == getrcconfigint("rcexit", NULL))
1628	{
1629	if(timernode != NULL && scaninfo.threadend == 0)
1630	{
1631	timernode->aktion = STOP;
1632	while(i < 4 && scaninfo.threadend == 0)
1633	{
1634	textbox(_("Message"), _("Wait for channel scan end"), NULL, 0, NULL, 0, NULL, 0, NULL, 0, 600, 200, 3, 0);
1635	i++;
1636	}
1637	}
1638	break;
1639	}
1640	}
1641
1642	if(scantype == 0) deltransponderbyid(99);
1643	if(clear == 1)
1644	{
1645	// favtype 0 = unchanged
1646	// favtype 1 = create new
1647	// favtype 2 = delete
1648
1649	if(favtype == 1)
1650	{
1651	freemainbouquet(1);
1652	struct provider *pnode = provider;
1653
1654	while(pnode != NULL)
1655	{
1656	provider2bouquet(pnode->providerid, 1);
1657	pnode = pnode->next;
1658	}
1659	}
1660	else if(favtype == 2)
1661	freemainbouquet(1);
1662
1663	if(emptybouquet == 1)
1664	delemptymainbouquet(1);
1665
1666	if(unusedbouquetchannels == 1)
1667	delunusedbouquetchannels(0);
1668	else
1669	delunusedbouquetchannels(1);
1670	}
1671	delmarkedscreennodes(scan, 1);
1672	delownerrc(scan);
1673	clearscreen(scan);
1674	resetsatscan();
1675	drawscreen(load, 0, 0);
1676	sortchannel();
1677	clearscreen(load);
1678	}
1679
1680	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)
1681	{
1682	struct sat* satnode = sat;
1683	struct skin* tmp = NULL;
1684	char* tmpstr = NULL, tmpstr1 = NULL, tmpnr = NULL;
1685	char* feshortname = NULL;
1686	int i, orbitalpos = 0;
1687
1688	if(tuner != NULL) feshortname = tuner->ret;
1689
1690	tuner->hidden = NO;
1691	id->hidden = NO;
1692	system->hidden = NO;
1693	frequency->hidden = NO;
1694	inversion->hidden = NO;
1695	symbolrate->hidden = NO;
1696	polarization->hidden = NO;
1697	fec->hidden = NO;
1698	modulation->hidden = NO;
1699	rolloff->hidden = NO;
1700	pilot->hidden = NO;
1701	hp->hidden = NO;
1702	lp->hidden = NO;
1703	bandwidth->hidden = NO;
1704	transmission->hidden = NO;
1705	guardinterval->hidden = NO;
1706	hierarchy->hidden = NO;
1707	satellite->hidden = NO;
1708	b4->hidden = NO;
1709	b5->hidden = NO;
1710	delmarkedscreennodes(scan, 1);
1711
1712	if(flag == 0 && ostrcmp(scantype, "0") == 0 && ostrcmp(system->ret, "0") == 0)
1713	{
1714	modulation->hidden = YES;
1715	rolloff->hidden = YES;
1716	pilot->hidden = YES;
1717	}
1718
1719	if(ostrcmp(scantype, "1") == 0 \|\| ostrcmp(scantype, "2") == 0 \|\| ostrcmp(scantype, "3") == 0)
1720	{
1721	id->hidden = YES;
1722	system->hidden = YES;
1723	frequency->hidden = YES;
1724	inversion->hidden = YES;
1725	symbolrate->hidden = YES;
1726	polarization->hidden = YES;
1727	fec->hidden = YES;
1728	modulation->hidden = YES;
1729	rolloff->hidden = YES;
1730	pilot->hidden = YES;
1731	hp->hidden = YES;
1732	lp->hidden = YES;
1733	bandwidth->hidden = YES;
1734	transmission->hidden = YES;
1735	guardinterval->hidden = YES;
1736	hierarchy->hidden = YES;
1737	b4->hidden = YES;
1738	b5->hidden = YES;
1739	}
1740	if(ostrcmp(scantype, "2") == 0 && feshortname != NULL)
1741	{
1742	satellite->hidden = YES;
1743
1744	tmpstr = ostrcat(feshortname, "_sat", 0, 0);
1745	for(i = 1; i <= getmaxsat(feshortname); i++)
1746	{
1747	tmpnr = oitoa(i);
1748	orbitalpos = getconfigint(tmpstr, tmpnr);
1749	free(tmpnr); tmpnr = NULL;
1750
1751	satnode = getsatbyorbitalpos(orbitalpos);
1752	if(satnode != NULL && satnode->fetype == FE_QPSK)
1753	{
1754	tmp = addlistbox(scan, listbox, tmp, 1);
1755	if(tmp != NULL)
1756	{
1757	tmpstr1 = oitoa(satnode->orbitalpos);
1758	changename(tmp, tmpstr1);
1759	free(tmpstr1); tmpstr1 = NULL;
1760	changetext(tmp, satnode->name);
1761	tmp->type = CHOICEBOX;
1762	addchoicebox(tmp, "0", _("no"));
1763	addchoicebox(tmp, "1", _("yes"));
1764	}
1765	}
1766	}
1767	free(tmpstr); tmpstr = NULL;
1768	}
1769	if(ostrcmp(scantype, "3") == 0)
1770	{
1771	tuner->hidden = YES;
1772	satellite->hidden = YES;
1773	}
1774
1775	if(flag == 2)
1776	{
1777	system->hidden = YES;
1778	inversion->hidden = YES;
1779	polarization->hidden = YES;
1780	rolloff->hidden = YES;
1781	pilot->hidden = YES;
1782	satellite->hidden = YES;
1783	}
1784
1785	if(flag == 3)
1786	{
1787	system->hidden = YES;
1788	polarization->hidden = YES;
1789	rolloff->hidden = YES;
1790	pilot->hidden = YES;
1791	satellite->hidden = YES;
1792	symbolrate->hidden = YES;
1793	fec->hidden = YES;
1794	}
1795	else
1796	{
1797	hp->hidden = YES;
1798	lp->hidden = YES;
1799	bandwidth->hidden = YES;
1800	transmission->hidden = YES;
1801	guardinterval->hidden = YES;
1802	hierarchy->hidden = YES;
1803	}
1804	}
1805
1806	void scanchangesat(struct skin* sat, struct transponder* tpnode, char* feshortname)
1807	{
1808	char* tmpstr = NULL;
1809
1810	changeinput(sat, NULL);
1811	changechoiceboxvalue(sat, NULL);
1812	tmpstr = getsatstring(feshortname, FE_QPSK);
1813	changeinput(sat, tmpstr);
1814	free(tmpstr); tmpstr = NULL;
1815	tmpstr = getorbitalposstring(feshortname, FE_QPSK);
1816	changechoiceboxvalue(sat, tmpstr);
1817	free(tmpstr); tmpstr = NULL;
1818	if(tpnode != NULL)
1819	{
1820	tmpstr = oitoa(tpnode->orbitalpos);
1821	setchoiceboxselection(sat, tmpstr);
1822	free(tmpstr); tmpstr = NULL;
1823	}
1824	}
1825
1826	//flag 0: manual scan (DVB-S)
1827	//flag 1: auto scan (all)
1828	//flag 2: manual scan (DVB-C)
1829	//flag 3: manual scan (DVB-T)
1830	void screenscanconfig(int flag)
1831	{
1832	int rcret = 0, fetype = -1;
1833	unsigned int ifrequency = -1, isymbolrate = -1;
1834	int iscantype = -1, isat = -1;
1835	int iinversion = -1, ipolarization = -1;
1836	int ifec = -1, imodulation = -1, irolloff = -1, ipilot = -1, isystem = -1;
1837	int inetworkscan = -1, ionlyfree = -1, iclear = -1, iblindscan = -1, ichangename = -1;
1838	int ifavtype = -1, iemptybouquet = -1, iunusedbouquetchannels = -1;
1839	int i = 0, treffer = 0, tunercount = 0;
1840	struct skin* scan = getscreen("manualscan");
1841	struct skin* listbox = getscreennode(scan, "listbox");
1842	struct skin* tuner = getscreennode(scan, "tuner");
1843	struct skin* scantype = getscreennode(scan, "scantype");
1844	struct skin* sat = getscreennode(scan, "sat");
1845	struct skin* id = getscreennode(scan, "id");
1846	struct skin* system = getscreennode(scan, "system");
1847	struct skin* frequency = getscreennode(scan, "frequency");
1848	struct skin* inversion = getscreennode(scan, "inversion");
1849	struct skin* symbolrate = getscreennode(scan, "symbolrate");
1850	struct skin* polarization = getscreennode(scan, "polarization");
1851	struct skin* fec = getscreennode(scan, "fec");
1852	struct skin* modulation = getscreennode(scan, "modulation");
1853	struct skin* rolloff = getscreennode(scan, "rolloff");
1854	struct skin* pilot = getscreennode(scan, "pilot");
1855	struct skin* hp = getscreennode(scan, "hp");
1856	struct skin* lp = getscreennode(scan, "lp");
1857	struct skin* bandwidth = getscreennode(scan, "bandwidth");
1858	struct skin* transmission = getscreennode(scan, "transmission");
1859	struct skin* guardinterval = getscreennode(scan, "guardinterval");
1860	struct skin* hierarchy = getscreennode(scan, "hierarchy");
1861	struct skin* networkscan = getscreennode(scan, "networkscan");
1862	struct skin* clear = getscreennode(scan, "clear");
1863	struct skin* onlyfree = getscreennode(scan, "onlyfree");
1864	struct skin* blindscan = getscreennode(scan, "blindscan");
1865	struct skin* changename = getscreennode(scan, "changename");
1866	struct skin* favtype = getscreennode(scan, "favtype");
1867	struct skin* emptybouquet = getscreennode(scan, "emptybouquet");
1868	struct skin* unusedbouquetchannels = getscreennode(scan, "unusedbouquetchannels");
1869
1870	struct skin* b4 = getscreennode(scan, "b4");
1871	struct skin* b5 = getscreennode(scan, "b5");
1872	struct skin* tmp = NULL;
1873	char* tmpstr = NULL, tmpnr = NULL, feshortname = NULL;
1874	struct transponder* tpnode = NULL;
1875	struct dvbdev* dvbnode = dvbdev;
1876
1877	listbox->aktline = 1;
1878	listbox->aktpage = -1;
1879
1880	if(status.recording > 0 \|\| status.streaming > 0)
1881	{
1882	textbox(_("Message"), _("Scan is not allowed if record or stream is running !"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 800, 200, 0, 0);
1883	return;
1884	}
1885
1886	//del old values
1887	changeinput(tuner, NULL);
1888	changechoiceboxvalue(tuner, NULL);
1889	changeinput(scantype, NULL);
1890	changechoiceboxvalue(scantype, NULL);
1891	changeinput(sat, NULL);
1892	changechoiceboxvalue(sat, NULL);
1893	changeinput(system, NULL);
1894	changechoiceboxvalue(system, NULL);
1895	changeinput(inversion, NULL);
1896	changechoiceboxvalue(inversion, NULL);
1897	changeinput(polarization, NULL);
1898	changechoiceboxvalue(polarization, NULL);
1899	changeinput(fec, NULL);
1900	changechoiceboxvalue(fec, NULL);
1901	changeinput(modulation, NULL);
1902	changechoiceboxvalue(modulation, NULL);
1903	changeinput(rolloff, NULL);
1904	changechoiceboxvalue(rolloff, NULL);
1905	changeinput(pilot, NULL);
1906	changechoiceboxvalue(pilot, NULL);
1907	changeinput(hp, NULL);
1908	changeinput(lp, NULL);
1909	changeinput(bandwidth, NULL);
1910	changeinput(transmission, NULL);
1911	changeinput(guardinterval, NULL);
1912	changeinput(hierarchy, NULL);
1913	changechoiceboxvalue(hp, NULL);
1914	changechoiceboxvalue(lp, NULL);
1915	changechoiceboxvalue(bandwidth, NULL);
1916	changechoiceboxvalue(transmission, NULL);
1917	changechoiceboxvalue(guardinterval, NULL);
1918	changechoiceboxvalue(hierarchy, NULL);
1919
1920	frequency->aktpage = 0;
1921	symbolrate->aktpage = 0;
1922
1923	if(flag == 0) fetype = FE_QPSK;
1924	if(flag == 2) fetype = FE_QAM;
1925	if(flag == 3) fetype = FE_OFDM;
1926
1927	//tuner
1928	while(dvbnode != NULL)
1929	{
1930	if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo != NULL && dvbnode->felock < 1 && dvbnode->deactive == 0 && (flag == 1 \|\| dvbnode->feinfo->type == fetype))
1931	{
1932	treffer = 0;
1933	if(dvbnode->feshortname != NULL)
1934	{
1935	tmpstr = ostrcat(dvbnode->feshortname, "_sat", 0, 0);
1936	for(i = 1; i <= getmaxsat(dvbnode->feshortname); i++)
1937	{
1938	tmpnr = oitoa(i);
1939	if(getconfigint(tmpstr, tmpnr) != 0)
1940	{
1941	treffer = 1;
1942	break;
1943	}
1944	free(tmpnr); tmpnr = NULL;
1945	}
1946	free(tmpnr); tmpnr = NULL;
1947	free(tmpstr); tmpstr = NULL;
1948	}
1949
1950	if(treffer == 0)
1951	{
1952	dvbnode = dvbnode->next;
1953	continue;
1954	}
1955
1956	tunercount++;
1957	if(feshortname == NULL) feshortname = dvbnode->feshortname;
1958
1959	tmpstr = ostrcat(tmpstr, dvbnode->feinfo->name, 1, 0);
1960	tmpstr = ostrcat(tmpstr, " (", 1, 0);
1961	tmpstr = ostrcat(tmpstr, oitoa(dvbnode->adapter), 1, 1);
1962	tmpstr = ostrcat(tmpstr, "/", 1, 0);
1963	tmpstr = ostrcat(tmpstr, oitoa(dvbnode->devnr), 1, 1);
1964	tmpstr = ostrcat(tmpstr, ")", 1, 0);
1965	addchoicebox(tuner, dvbnode->feshortname, tmpstr);
1966	free(tmpstr); tmpstr = NULL;
1967	}
1968	dvbnode = dvbnode->next;
1969	}
1970
1971	if(tunercount < 1)
1972	{
1973	textbox(_("Message"), _("No Tuner configured"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 800, 200, 0, 0);
1974	return;
1975	}
1976
1977	rcret = servicestop(status.aktservice, 1, 1);
1978	if(rcret == 1) return;
1979
1980	if(status.aktservice->channel != NULL)
1981	tpnode = status.aktservice->channel->transponder;
1982
1983	//clear akt and last channel, so all channel can delete
1984	freechannelhistory();
1985	status.lastservice->channel = NULL;
1986	status.aktservice->channel = NULL;
1987
1988	start:
1989
1990	if(flag == 0)
1991	{
1992	addchoicebox(scantype, "0", _("Single Transponder"));
1993	addchoicebox(scantype, "1", _("Single Sat"));
1994	addchoicebox(scantype, "2", _("Multi Sat"));
1995	setchoiceboxselection(scantype, "0");
1996	}
1997	else if(flag == 2 \|\| flag == 3)
1998	{
1999	addchoicebox(scantype, "0", _("Single Transponder"));
2000	addchoicebox(scantype, "1", _("Single Provider"));
2001	setchoiceboxselection(scantype, "0");
2002	}
2003	else
2004	{
2005	addchoicebox(scantype, "3", _("Auto Scan"));
2006	setchoiceboxselection(scantype, "3");
2007	}
2008
2009	//sat
2010	scanchangesat(sat, tpnode, feshortname);
2011
2012	//id
2013	if(tpnode != NULL)
2014	tmpstr = ollutoa(tpnode->id);
2015	changeinput(id, tmpstr);
2016	free(tmpstr); tmpstr = NULL;
2017
2018	//system
2019	tmpstr = transpondergetsystemstr(tpnode, 1);
2020	changeinput(system, tmpstr);
2021	free(tmpstr); tmpstr = NULL;
2022	tmpstr = transpondergetsystemstr(tpnode, 2);
2023	changechoiceboxvalue(system, tmpstr);
2024	free(tmpstr); tmpstr = NULL;
2025	if(tpnode != NULL)
2026	{
2027	tmpstr = oitoa(tpnode->system);
2028	setchoiceboxselection(system, tmpstr);
2029	free(tmpstr); tmpstr = NULL;
2030	}
2031
2032	//frequency
2033	if(tpnode != NULL)
2034	tmpstr = oitoa(tpnode->frequency / 1000);
2035	else
2036	{
2037	if(flag == 3)
2038	tmpstr = ostrcat(tmpstr, "000000", 1, 0);
2039	else
2040	tmpstr = ostrcat(tmpstr, "00000", 1, 0);
2041	}
2042	if(flag == 2 \|\| flag == 3)
2043	{
2044	changemask(frequency, "000000");
2045	changeinput(frequency, tmpstr);
2046	frequency->input = mask(frequency->input, 6, "0");
2047	}
2048	else
2049	{
2050	changemask(frequency, "00000");
2051	changeinput(frequency, tmpstr);
2052	frequency->input = mask(frequency->input, 5, "0");
2053	}
2054	free(tmpstr); tmpstr = NULL;
2055
2056	//inversion
2057	tmpstr = transpondergetinversionstr(tpnode, 1);
2058	changeinput(inversion, tmpstr);
2059	free(tmpstr); tmpstr = NULL;
2060	tmpstr = transpondergetinversionstr(tpnode, 2);
2061	changechoiceboxvalue(inversion, tmpstr);
2062	free(tmpstr); tmpstr = NULL;
2063	if(tpnode != NULL)
2064	{
2065	tmpstr = oitoa(tpnode->inversion);
2066	setchoiceboxselection(inversion, tmpstr);
2067	free(tmpstr); tmpstr = NULL;
2068	}
2069
2070	//symbolrate
2071	if(tpnode != NULL)
2072	tmpstr = oitoa(tpnode->symbolrate / 1000);
2073	else
2074	tmpstr = ostrcat(tmpstr, "00000", 1, 0);
2075	changemask(symbolrate, "00000");
2076	changeinput(symbolrate, tmpstr);
2077	symbolrate->input = mask(symbolrate->input, 5, "0");
2078	free(tmpstr); tmpstr = NULL;
2079
2080	//polarization
2081	tmpstr = transpondergetpolarizationstr(tpnode, 1);
2082	changeinput(polarization, tmpstr);
2083	free(tmpstr); tmpstr = NULL;
2084	tmpstr = transpondergetpolarizationstr(tpnode, 2);
2085	changechoiceboxvalue(polarization, tmpstr);
2086	free(tmpstr); tmpstr = NULL;
2087	if(tpnode != NULL)
2088	{
2089	tmpstr = oitoa(tpnode->polarization);
2090	setchoiceboxselection(polarization, tmpstr);
2091	free(tmpstr); tmpstr = NULL;
2092	}
2093
2094	//fec
2095	tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2096	changeinput(fec, tmpstr);
2097	free(tmpstr); tmpstr = NULL;
2098	tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2099	changechoiceboxvalue(fec, tmpstr);
2100	free(tmpstr); tmpstr = NULL;
2101	if(tpnode != NULL)
2102	{
2103	tmpstr = oitoa(tpnode->fec);
2104	setchoiceboxselection(fec, tmpstr);
2105	free(tmpstr); tmpstr = NULL;
2106	}
2107
2108	//modulation
2109	tmpstr = transpondergetmodulationstr(tpnode, fetype, 1);
2110	changeinput(modulation, tmpstr);
2111	free(tmpstr); tmpstr = NULL;
2112	tmpstr = transpondergetmodulationstr(tpnode, fetype, 2);
2113	changechoiceboxvalue(modulation, tmpstr);
2114	free(tmpstr); tmpstr = NULL;
2115	if(tpnode != NULL)
2116	{
2117	tmpstr = oitoa(tpnode->modulation);
2118	setchoiceboxselection(modulation, tmpstr);
2119	free(tmpstr); tmpstr = NULL;
2120	}
2121
2122	//rolloff
2123	tmpstr = transpondergetrolloffstr(tpnode, 1);
2124	changeinput(rolloff, tmpstr);
2125	free(tmpstr); tmpstr = NULL;
2126	tmpstr = transpondergetrolloffstr(tpnode, 2);
2127	changechoiceboxvalue(rolloff, tmpstr);
2128	free(tmpstr); tmpstr = NULL;
2129	if(tpnode != NULL)
2130	{
2131	tmpstr = oitoa(tpnode->rolloff);
2132	setchoiceboxselection(rolloff, tmpstr);
2133	free(tmpstr); tmpstr = NULL;
2134	}
2135
2136	//pilot
2137	tmpstr = transpondergetpilotstr(tpnode, 1);
2138	changeinput(pilot, tmpstr);
2139	free(tmpstr); tmpstr = NULL;
2140	tmpstr = transpondergetpilotstr(tpnode, 2);
2141	changechoiceboxvalue(pilot, tmpstr);
2142	free(tmpstr); tmpstr = NULL;
2143	if(tpnode != NULL)
2144	{
2145	tmpstr = oitoa(tpnode->pilot);
2146	setchoiceboxselection(pilot, tmpstr);
2147	free(tmpstr); tmpstr = NULL;
2148	}
2149
2150	//hp
2151	tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2152	changeinput(hp, tmpstr);
2153	free(tmpstr); tmpstr = NULL;
2154	tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2155	changechoiceboxvalue(hp, tmpstr);
2156	free(tmpstr); tmpstr = NULL;
2157	if(tpnode != NULL)
2158	{
2159	tmpstr = oitoa(tpnode->fec);
2160	setchoiceboxselection(hp, tmpstr);
2161	free(tmpstr); tmpstr = NULL;
2162	}
2163
2164	//lp
2165	tmpstr = transpondergetfecstr(tpnode, fetype, 1);
2166	changeinput(lp, tmpstr);
2167	free(tmpstr); tmpstr = NULL;
2168	tmpstr = transpondergetfecstr(tpnode, fetype, 2);
2169	changechoiceboxvalue(lp, tmpstr);
2170	free(tmpstr); tmpstr = NULL;
2171	if(tpnode != NULL)
2172	{
2173	tmpstr = oitoa(tpnode->polarization);
2174	setchoiceboxselection(lp, tmpstr);
2175	free(tmpstr); tmpstr = NULL;
2176	}
2177
2178	//bandwidth
2179	tmpstr = transpondergetbandwidthstr(tpnode, 1);
2180	changeinput(bandwidth, tmpstr);
2181	free(tmpstr); tmpstr = NULL;
2182	tmpstr = transpondergetbandwidthstr(tpnode, 2);
2183	changechoiceboxvalue(bandwidth, tmpstr);
2184	free(tmpstr); tmpstr = NULL;
2185	if(tpnode != NULL)
2186	{
2187	tmpstr = oitoa(tpnode->symbolrate);
2188	setchoiceboxselection(bandwidth, tmpstr);
2189	free(tmpstr); tmpstr = NULL;
2190	}
2191
2192	//guardinterval
2193	tmpstr = transpondergetguardintervalstr(tpnode, 1);
2194	changeinput(guardinterval, tmpstr);
2195	free(tmpstr); tmpstr = NULL;
2196	tmpstr = transpondergetguardintervalstr(tpnode, 2);
2197	changechoiceboxvalue(guardinterval, tmpstr);
2198	free(tmpstr); tmpstr = NULL;
2199	if(tpnode != NULL)
2200	{
2201	tmpstr = oitoa(tpnode->rolloff);
2202	setchoiceboxselection(guardinterval, tmpstr);
2203	free(tmpstr); tmpstr = NULL;
2204	}
2205
2206	//transmission
2207	tmpstr = transpondergettransmissionstr(tpnode, 1);
2208	changeinput(transmission, tmpstr);
2209	free(tmpstr); tmpstr = NULL;
2210	tmpstr = transpondergettransmissionstr(tpnode, 2);
2211	changechoiceboxvalue(transmission, tmpstr);
2212	free(tmpstr); tmpstr = NULL;
2213	if(tpnode != NULL)
2214	{
2215	tmpstr = oitoa(tpnode->pilot);
2216	setchoiceboxselection(transmission, tmpstr);
2217	free(tmpstr); tmpstr = NULL;
2218	}
2219
2220	//hierarchy
2221	tmpstr = transpondergethierarchystr(tpnode, 1);
2222	changeinput(hierarchy, tmpstr);
2223	free(tmpstr); tmpstr = NULL;
2224	tmpstr = transpondergethierarchystr(tpnode, 2);
2225	changechoiceboxvalue(hierarchy, tmpstr);
2226	free(tmpstr); tmpstr = NULL;
2227	if(tpnode != NULL)
2228	{
2229	tmpstr = oitoa(tpnode->system);
2230	setchoiceboxselection(hierarchy, tmpstr);
2231	free(tmpstr); tmpstr = NULL;
2232	}
2233
2234	//networkscan
2235	addchoicebox(networkscan, "0", _("no"));
2236	addchoicebox(networkscan, "1", _("yes"));
2237
2238	//clear
2239	addchoicebox(clear, "0", _("no"));
2240	addchoicebox(clear, "1", _("yes"));
2241
2242	//only free
2243	addchoicebox(onlyfree, "0", _("no"));
2244	addchoicebox(onlyfree, "1", _("yes"));
2245
2246	//blindscan
2247	addchoicebox(blindscan, "0", _("no"));
2248	addchoicebox(blindscan, "1", _("yes"));
2249
2250	//changename
2251	addchoicebox(changename, "0", _("no"));
2252	addchoicebox(changename, "1", _("yes"));
2253
2254	//favtype
2255	addchoicebox(favtype, "0", _("Unchanged"));
2256	addchoicebox(favtype, "1", _("Create new"));
2257	addchoicebox(favtype, "2", _("Delete All"));
2258
2259	//emptybouquet
2260	addchoicebox(emptybouquet, "0", _("no"));
2261	addchoicebox(emptybouquet, "1", _("yes"));
2262
2263	//unusedbouquetchannels
2264	addchoicebox(unusedbouquetchannels, "0", _("no"));
2265	addchoicebox(unusedbouquetchannels, "1", _("yes"));
2266
2267	drawscreen(scan, 2, 0);
2268	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);
2269	drawscreen(scan, 0, 0);
2270	addscreenrc(scan, listbox);
2271
2272	tmp = listbox->select;
2273	while(1)
2274	{
2275	addscreenrc(scan, tmp);
2276	rcret = waitrc(scan, 0, 0);
2277	tmp = listbox->select;
2278
2279	if(scantype->ret != NULL) iscantype = atoi(scantype->ret);
2280	if(sat->ret != NULL) isat = atoi(sat->ret);
2281	if(system->ret != NULL) isystem = atoi(system->ret);
2282	if(frequency->ret != NULL) ifrequency = atoi(frequency->ret) * 1000;
2283	if(inversion->ret != NULL) iinversion = atoi(inversion->ret);
2284	if(symbolrate->ret != NULL) isymbolrate = atoi(symbolrate->ret) * 1000;
2285	if(polarization->ret != NULL) ipolarization = atoi(polarization->ret);
2286	if(fec->ret != NULL) ifec = atoi(fec->ret);
2287	if(modulation->ret != NULL) imodulation = atoi(modulation->ret);
2288	if(rolloff->ret != NULL) irolloff = atoi(rolloff->ret);
2289	if(pilot->ret != NULL) ipilot = atoi(pilot->ret);
2290
2291	if(flag == 3)
2292	{
2293	if(hp->ret != NULL) ifec = atoi(hp->ret);
2294	if(lp->ret != NULL) ipolarization = atoi(lp->ret);
2295	if(bandwidth->ret != NULL) isymbolrate = atoi(bandwidth->ret);
2296	if(transmission->ret != NULL) ipilot = atoi(transmission->ret);
2297	if(guardinterval->ret != NULL) irolloff = atoi(guardinterval->ret);
2298	if(hierarchy->ret != NULL) isystem = atoi(hierarchy->ret);
2299	}
2300
2301	if(networkscan->ret != NULL) inetworkscan = atoi(networkscan->ret);
2302	if(onlyfree->ret != NULL) ionlyfree = atoi(onlyfree->ret);
2303	if(clear->ret != NULL) iclear = atoi(clear->ret);
2304	if(blindscan->ret != NULL) iblindscan = atoi(blindscan->ret);
2305	if(changename->ret != NULL) ichangename = atoi(changename->ret);
2306	if(favtype->ret != NULL) ifavtype = atoi(favtype->ret);
2307	if(emptybouquet->ret != NULL) iemptybouquet = atoi(emptybouquet->ret);
2308	if(unusedbouquetchannels->ret != NULL) iunusedbouquetchannels = atoi(unusedbouquetchannels->ret);
2309
2310	if(rcret == getrcconfigint("rcexit", NULL)) break;
2311	if(rcret == getrcconfigint("rcok", NULL)) break;
2312	if(listbox->select != NULL && ostrcmp(listbox->select->name, "tuner") == 0)
2313	{
2314	scanchangesat(sat, tpnode, listbox->select->ret);
2315	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);
2316	drawscreen(scan, 0, 0);
2317	}
2318	if(listbox->select != NULL && ostrcmp(listbox->select->name, "scantype") == 0)
2319	{
2320	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);
2321	drawscreen(scan, 0, 0);
2322	}
2323	if(listbox->select != NULL && ostrcmp(listbox->select->name, "system") == 0)
2324	{
2325	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);
2326	drawscreen(scan, 0, 0);
2327	}
2328	if(rcret == getrcconfigint("rcred", NULL))
2329	{
2330	clearscreen(scan);
2331	screenscan(tpnode, scan->child, tuner->ret, iscantype, isat, ifrequency, iinversion, isymbolrate, ipolarization, ifec, imodulation, irolloff, ipilot, inetworkscan, ionlyfree, iclear, iblindscan, ichangename, isystem, ifavtype, iemptybouquet, iunusedbouquetchannels, 5000000);
2332	drawscreen(scan, 0, 0);
2333	}
2334	if(rcret == getrcconfigint("rcgreen", NULL) && tpnode != NULL && iscantype == 0)
2335	{
2336	struct transponder* tp1 = createtransponder(99, tpnode->fetype, isat, ifrequency, iinversion, isymbolrate, ipolarization, ifec, imodulation, irolloff, ipilot, isystem);
2337	copytransponder(tp1, tpnode, 99);
2338	deltransponderbyid(99);
2339	textbox(_("Message"), _("Transponder changed"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
2340	drawscreen(scan, 0, 0);
2341	}
2342	if(rcret == getrcconfigint("rcyellow", NULL) && iscantype == 0)
2343	{
2344	struct transponder* tp = tpchoicescreen(isat, flag);
2345	if(tp != NULL)
2346	{
2347	tpnode = tp;
2348	goto start;
2349	}
2350	else
2351	drawscreen(scan, 0, 0);
2352	}
2353	else if(rcret == getrcconfigint("rcok", NULL))
2354	break;
2355	}
2356
2357	delmarkedscreennodes(scan, 1);
2358	delownerrc(scan);
2359	clearscreen(scan);
2360	resetsatscan();
2361
2362	if(status.lastservice->channel == NULL)
2363	{
2364	if(getchannel(getconfigint("serviceid", NULL), getconfigllu("transponderid", NULL)) != NULL)
2365	{
2366	if(status.servicetype == 0)
2367	servicecheckret(servicestart(getchannel(getconfigint("serviceid", NULL), getconfigllu("transponderid", NULL)), getconfig("channellist", NULL), NULL, 0), 0);
2368	else
2369	servicecheckret(servicestart(getchannel(getconfigint("rserviceid", NULL), getconfigllu("rtransponderid", NULL)), getconfig("rchannellist", NULL), NULL, 0), 0);
2370	}
2371	}
2372	else
2373	{
2374	tmpstr = ostrcat(status.lastservice->channellist, NULL, 0, 0);
2375	servicecheckret(servicestart(status.lastservice->channel, tmpstr, NULL, 0), 0);
2376	free(tmpstr); tmpstr = NULL;
2377	}
2378
2379	//recalc channels
2380	struct channel* chnode = channel;
2381	while(chnode != NULL)
2382	{
2383	if(chnode->servicetype != 99)
2384	{
2385	chnode->transponder = gettransponder(chnode->transponderid);
2386	chnode->provider = getprovider(chnode->providerid);
2387	}
2388	chnode = chnode->next;
2389	}
2390
2391	writeallconfig(1);
2392	}
2393
2394	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: