Context Navigation

source: titan/titan/mipselport.h @ 37119

Last change on this file since 37119 was 37119, checked in by gost, 8 years ago
[titan] mipsel.. new animations
File size: 38.8 KB

Line
1	#ifndef MIPSELPORT_H
2	#define MIPSELPORT_H
3
4	#ifndef FBIO_BLIT
5	//#define FBIO_SET_MANUAL_BLIT _IOW('F', 0x20, __u32)
6	#define FBIO_SET_MANUAL_BLIT _IOW('F', 0x21, __u8)
7	#define FBIO_BLIT 0x22
8	#endif
9
10	#ifndef FBIO_WAITFORVSYNC
11	#define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32)
12	#endif
13
14	//fuer Funktion memcpy_word
15	volatile char *memcpy_word_src;
16	volatile char *memcpy_word_dest;
17	volatile long memcpy_word_anzw = 0;
18
19	//fuer Funktion memcpy_byte
20	volatile char *memcpy_byte_src;
21	volatile char *memcpy_byte_dest;
22	volatile long memcpy_byte_anzb = 0;
23
24	unsigned char *lfb = NULL;
25	int g_manual_blit = 0;
26	struct fb_fix_screeninfo fix_screeninfo;
27	struct fb_var_screeninfo var_screeninfo;
28
29	void memcpy_area(unsigned char* targetADDR, unsigned char* startADDR, long pxAbs, long hight, long widthAbs, long FBwidthAbs);
30
31	int setmixer(struct dvbdev* node, int left, int right)
32	{
33	return audiosetmixer(node, left, right);
34	}
35
36	int setencoding(struct channel* chnode, struct dvbdev* videonode)
37	{
38	int ret = 1;
39	if(chnode == NULL) return ret;
40
41	switch(chnode->videocodec)
42	{
43	case MPEGV:
44	ret = videosetstreamtype(videonode, 0);
45	break;
46	case MPEG4V:
47	ret = videosetstreamtype(videonode, 4);
48	break;
49	case H264:
50	ret = videosetstreamtype(videonode, 1);
51	break;
52	case VC1:
53	ret = videosetstreamtype(videonode, 3);
54	break;
55	default:
56	ret = videosetstreamtype(videonode, 0);
57	}
58	return ret;
59	}
60
61	int videodiscontinuityskip(struct dvbdev* node, int flag)
62	{
63	return 0;
64	}
65
66	void fbsave()
67	{
68	}
69
70	void fbrestore()
71	{
72	}
73
74	void setfbvarsize(struct fb* newnode)
75	{
76	if(newnode != NULL)
77	newnode->varfbsize = 1920 * 1080 * newnode->colbytes;
78	// newnode->varfbsize = 1920 * 1080 * (newnode->colbytes * 8);
79
80	}
81
82	void enablemanualblit()
83	{
84	unsigned char tmp = 1;
85	if (ioctl(fb->fd, FBIO_SET_MANUAL_BLIT, &tmp)<0)
86	perror("FBIO_SET_MANUAL_BLIT");
87	else
88	g_manual_blit = 1;
89	}
90
91	void disablemanualblit()
92	{
93	unsigned char tmp = 0;
94	if (ioctl(fb->fd, FBIO_SET_MANUAL_BLIT, &tmp)<0)
95	perror("FBIO_SET_MANUAL_BLIT");
96	else
97	g_manual_blit = 0;
98	}
99
100	void blit()
101	{
102	if (g_manual_blit == 1) {
103	if (ioctl(fb->fd, FBIO_BLIT) < 0)
104	perror("FBIO_BLIT");
105	}
106	}
107
108	int waitvsync()
109	{
110	int c = 0;
111	return ioctl(fb->fd, FBIO_WAITFORVSYNC, &c);
112	}
113
114	void fbsetoffset(int x, int y)
115	{
116	struct fb_var_screeninfo var_screeninfo;
117
118	var_screeninfo.xoffset = x;
119	var_screeninfo.yoffset = y;
120
121	if(ioctl(fb->fd, FBIOPAN_DISPLAY, &var_screeninfo) < 0)
122	{
123	perr("FBIOPAN_DISPLAY");
124	}
125	}
126
127	//flag 0 = no animation
128	//flag 1 = animation
129	void blitfb2(struct fb* fbnode, int flag)
130	{
131	int doblit = 1;
132	struct fb_var_screeninfo var_screeninfo;
133
134	var_screeninfo.xres_virtual = fb->width;
135	var_screeninfo.xres = fb->width;
136	var_screeninfo.yres_virtual = fb->height * 2;
137	var_screeninfo.yres = fb->height;
138	var_screeninfo.height = 0;
139	var_screeninfo.width = 0;
140	var_screeninfo.xoffset = 0;
141	var_screeninfo.yoffset = 0;
142	var_screeninfo.bits_per_pixel = fb->colbytes * 8;
143
144	switch(fb->colbytes)
145	{
146	case 2:
147	var_screeninfo.transp.offset = 15;
148	var_screeninfo.transp.length = 1;
149	var_screeninfo.red.offset = 10;
150	var_screeninfo.red.length = 5;
151	var_screeninfo.green.offset = 5;
152	var_screeninfo.green.length = 5;
153	var_screeninfo.blue.offset = 0;
154	var_screeninfo.blue.length = 5;
155	break;
156	case 4:
157	var_screeninfo.transp.offset = 24;
158	var_screeninfo.transp.length = 8;
159	var_screeninfo.red.offset = 16;
160	var_screeninfo.red.length = 8;
161	var_screeninfo.green.offset = 8;
162	var_screeninfo.green.length = 8;
163	var_screeninfo.blue.offset = 0;
164	var_screeninfo.blue.length = 8;
165	break;
166	}
167
168	debug(444, "FB: line_length %d", fix_screeninfo.line_length);
169	debug(444, "FB: var_screeninfo.xres %d", var_screeninfo.xres);
170	debug(444, "FB: var_screeninfo.yres %d", var_screeninfo.yres);
171	debug(444, "FB: var_screeninfo.xres_virt %d", var_screeninfo.xres_virtual);
172	debug(444, "FB: var_screeninfo.yres_virt %d", var_screeninfo.yres_virtual);
173	debug(444, "FB: var_screeninfo.xoffset %d", var_screeninfo.xoffset);
174	debug(444, "FB: var_screeninfo.yoffset %d", var_screeninfo.yoffset);
175	debug(444, "FB: var_screeninfo.bits_per_pixel %d", var_screeninfo.bits_per_pixel);
176	debug(444, "FB: var_screeninfo.grayscale %d", var_screeninfo.grayscale);
177
178	if(ioctl(fb->fd, FBIOPUT_VSCREENINFO, &var_screeninfo) < 0)
179	{
180	var_screeninfo.yres_virtual = fb->height;
181	if(ioctl(fb->fd, FBIOPUT_VSCREENINFO, &var_screeninfo) < 0)
182	{
183	perr("FBIOPUT_VSCREENINFO");
184	}
185	debug(444, "FB: double buffering not available");
186	}
187	else
188	{
189	debug(444, "FB: double buffering available!");
190	}
191
192	ioctl(fb->fd, FBIOGET_VSCREENINFO, &var_screeninfo);
193	if ((var_screeninfo.xres!=fb->width) && (var_screeninfo.yres!=fb->height) && (var_screeninfo.bits_per_pixel!=fb->colbytes))
194	{
195	debug(444, "SetMode failed: wanted: %dx%dx%d, got %dx%dx%d",
196	fb->width, fb->height, fb->colbytes,
197	var_screeninfo.xres, var_screeninfo.yres, var_screeninfo.bits_per_pixel);
198	}
199
200	int posx = 0;
201	int posy = 0;
202	int width = 0;
203	int height = 0;
204
205	if(status.bcm == 1 && status.usedirectfb == 0)
206	{
207	width = (fb->width - posx) - (getconfigint("fbrightoffset", NULL) * 5);
208	height = (fb->height - posy) - (getconfigint("fbbottomoffset", NULL) * 5);
209	posx = getconfigint("fbleftoffset", NULL) * 5;
210	posy = getconfigint("fbtopoffset", NULL) * 5;
211	}
212	else
213	{
214	width = (720 - posx) - (getconfigint("fbrightoffset", NULL));
215	height = (576 - posy) - (getconfigint("fbbottomoffset", NULL));
216	posx = getconfigint("fbleftoffset", NULL);
217	posy = getconfigint("fbtopoffset", NULL);
218	}
219
220	//printf("posx:%i posy:%i width:%i height:%i\n", posx, posy, width, height);
221
222	int i = 0, max = 1, wstep = 0, hstep = 0;
223	int dst_left = 0, dst_width = 0, dst_top = 0, dst_height = 0;
224	int mode3d = 0;
225
226	if(flag == 0)
227	{
228	if(status.bcm == 1 && status.usedirectfb == 0)
229	bcm_accel_blit(skinfb->data_phys, skinfb->width, skinfb->height, skinfb->pitch, 0, fb->data_phys, fb->width, fb->height, fb->pitch, 0, 0, skinfb->width, skinfb->height, posx, posy, width, height, 0, 0);
230	else
231	blit();
232	}
233
234	if(flag == 1 && status.screenanim > 0 && mode3d == 0)
235	{
236	doblit = 0;
237	//max = 25;
238	max = 8;
239	dst_left = posx;
240	dst_width = width;
241	dst_top = posy;
242	dst_height = height;
243
244	char* fbleftdev = "/proc/stb/fb/dst_left";
245	char* fbwidthdev = "/proc/stb/fb/dst_width";
246	char* fbtopdev = "/proc/stb/fb/dst_top";
247	char* fbheightdev = "/proc/stb/fb/dst_height";
248
249	if(status.screenanim == 1 \|\| status.screenanim == 3)
250	{
251	dst_left = (width / 2) - 1;
252	dst_width = 2;
253	}
254	if(status.screenanim == 2 \|\| status.screenanim == 3)
255	{
256	dst_top = (height / 2) - 1;
257	dst_height = 2;
258	}
259	if(status.screenanim == 4)
260	{
261	dst_top = posy;
262	dst_height = height;
263	dst_left = posx;
264	dst_width = 2;
265	}
266	if(status.screenanim == 5)
267	{
268	dst_top = posy;
269	dst_height = 2;
270	dst_left = posx;
271	dst_width = width;
272	}
273
274	wstep = width / max;
275	hstep = height / max;
276
277	for(i = 0; i <= max; i++)
278	{
279	if(status.screenanim == 1 \|\| status.screenanim == 3)
280	{
281	int tmpleft = dst_left - (wstep/2);
282	int tmpwidth = dst_width + wstep;
283	if(tmpleft < posx)
284	tmpleft = posx;
285	if(tmpwidth > width)
286	tmpwidth = width;
287	dst_left = tmpleft;
288	dst_width = tmpwidth;
289	}
290	if(status.screenanim == 2 \|\| status.screenanim == 3)
291	{
292	int tmptop = dst_top - (hstep/2);
293	int tmpheight = dst_height + hstep;
294	if(tmptop < posy)
295	tmptop = posy;
296	if(tmpheight > height)
297	tmpheight = height;
298	dst_top = tmptop;
299	dst_height = tmpheight;
300	}
301	if(status.screenanim == 4)
302	{
303	int tmpwidth = dst_width + wstep;
304	if(tmpwidth > width)
305	tmpwidth = width;
306	dst_width = tmpwidth;
307	}
308	if(status.screenanim == 5)
309	{
310	int tmpheight = dst_height + hstep;
311	if(tmpheight > height)
312	tmpheight = height;
313	dst_height = tmpheight;
314	}
315
316	if((dst_width + dst_left) > width)
317	dst_width = dst_width - dst_left;
318
319	if((dst_height + dst_top) > height)
320	dst_height = dst_height - dst_top;
321
322	//printf("left:%i width:%i top:%i height:%i\n", dst_left, dst_width, dst_top, dst_height);
323	//waitvsync();
324	if(status.bcm == 1 && status.usedirectfb == 0)
325	bcm_accel_blit(skinfb->data_phys, skinfb->width, skinfb->height, skinfb->pitch, 0, fb->data_phys, fb->width, fb->height, fb->pitch, 0, 0, skinfb->width, skinfb->height, dst_left, dst_top, dst_width, dst_height, 0, 0);
326	else
327	{
328	setfbosddev(fbleftdev, dst_left);
329	setfbosddev(fbwidthdev, dst_width);
330	setfbosddev(fbtopdev, dst_top);
331	setfbosddev(fbheightdev, dst_height);
332	usleep(1000);
333	}
334	if(status.screenanim > 0) usleep(status.screenanimspeed * 1000);
335	blit();
336	}
337	if(status.bcm == 1 && status.usedirectfb == 0)
338	bcm_accel_blit(skinfb->data_phys, skinfb->width, skinfb->height, skinfb->pitch, 0, fb->data_phys, fb->width, fb->height, fb->pitch, 0, 0, skinfb->width, skinfb->height, posx, posy, width, height, 0, 0);
339	else
340	{
341	setfbosddev(fbleftdev, posx);
342	setfbosddev(fbwidthdev, width);
343	setfbosddev(fbtopdev, posy);
344	setfbosddev(fbheightdev, height);
345	}
346	blit();
347	}
348	else
349	bcm_accel_blit(skinfb->data_phys, skinfb->width, skinfb->height, skinfb->pitch, 0, fb->data_phys, fb->width, fb->height, fb->pitch, 0, 0, skinfb->width, skinfb->height, posx, posy, width, height, 0, 0);
350
351	if(doblit == 1)
352	blit();
353
354	/*
355	int xRes, yRes, stride, bpp;
356
357	xRes=var_screeninfo.xres;
358	yRes=var_screeninfo.yres;
359	bpp=var_screeninfo.bits_per_pixel;
360	// fb_fix_screeninfo fix;
361	// struct fb_fix_screeninfo fix_screeninfo;
362	if (ioctl(fb->fd, FBIOGET_FSCREENINFO, &fix_screeninfo)<0)
363	{
364	perror("FBIOGET_FSCREENINFO");
365	printf("fb failed\n");
366	}
367	stride=fix_screeninfo.line_length;
368	memset(lfb, 0, stride*yRes);
369	*/
370	// blit();
371
372	/*
373	int i = 0, max = 1, wstep = 0, hstep = 0, ret = 0;
374	unsigned char buf[10];
375
376	if(fbnode == NULL) return;
377	#ifndef NOHWBLIT
378	if(fbnode == fb) return;
379
380	if(status.rguidfd > -1)
381	{
382	m_lock(&status.accelfbmutex, 16);
383
384	int zlen = 0;
385	char* zbuf = NULL;
386	blitscale(0, 0, fbnode->width, fbnode->height, 440, 330, 1);
387	ret = ozip((char)accelfb->fb, 440 330 * 4, &zbuf, &zlen, 1);
388
389	if(ret == 0)
390	{
391	memset(buf, 0, 10);
392	char* tmpnr = oitoa(zlen);
393	memcpy(buf, tmpnr, strlen(tmpnr));
394	free(tmpnr); tmpnr = NULL;
395	socksend(&status.rguidfd, buf, 10, 5000 * 1000);
396	socksend(&status.rguidfd, (unsigned char)zbuf, zlen, 5000 1000);
397	}
398	free(zbuf); zbuf = NULL;
399	zlen = 0;
400
401	m_unlock(&status.accelfbmutex, 16);
402	}
403
404	if(status.write_png == 1 && status.infobaraktiv == 0)
405	{
406	m_lock(&status.accelfbmutex, 16);
407	blitscale(0, 0, fbnode->width, fbnode->height, 320, 240, 1);
408	if(writeFBfile.ActBuf == NULL)
409	{
410	writeFBfile.buf1 = malloc(4 * 320 * 240);
411	writeFBfile.ActBuf = writeFBfile.buf1;
412	memcpy(writeFBfile.buf1, accelfb->fb, 4 * 320 * 240);
413	addtimer(&fb2png_thread, START, 10000, 1, NULL, NULL, NULL);
414	}
415	else if(writeFBfile.buf1 == writeFBfile.ActBuf)
416	{
417	if(writeFBfile.buf2 == NULL)
418	writeFBfile.buf2 = malloc(4 * 320 * 240);
419	memcpy(writeFBfile.buf2, accelfb->fb, 4 * 320 * 240);
420	}
421	else if(writeFBfile.buf2 == writeFBfile.ActBuf)
422	{
423	if(writeFBfile.buf1 == NULL)
424	writeFBfile.buf1 = malloc(4 * 320 * 240);
425	memcpy(writeFBfile.buf1, accelfb->fb, 4 * 320 * 240);
426	}
427	m_unlock(&status.accelfbmutex, 16);
428	}
429
430	int mode3d = 0, leftoffset = 0, rightoffset = 0, topoffset = 0, bottomoffset = 0;
431	char* mode3dstr = NULL;
432
433	if(status.leftoffset != 0) blitrect(0, 0, status.leftoffset, fb->height, 0, 255, 2);
434	if(status.rightoffset != 0) blitrect(fb->width - status.rightoffset, 0, status.rightoffset, fb->height, 0, 255, 2);
435	if(status.topoffset != 0) blitrect(0, 0, fb->width, status.topoffset, 0, 255, 2);
436	if(status.bottomoffset != 0) blitrect(0, fb->height - status.bottomoffset, fb->width, status.bottomoffset, 0, 255, 2);
437
438	mode3dstr = getconfig("av_mode3d", NULL);
439	if(ostrcmp(mode3dstr, "sbs") == 0)
440	mode3d = 1;
441	else if(ostrcmp(mode3dstr, "tab") == 0)
442	mode3d = 2;
443
444	STMFBIO_BLT_DATA bltData;
445	memset(&bltData, 0, sizeof(STMFBIO_BLT_DATA));
446
447	bltData.operation = BLT_OP_COPY;
448	bltData.srcOffset = fbnode->fb - fb->fb;
449	bltData.srcPitch = fbnode->pitch;
450	bltData.src_top = 0;
451	bltData.src_left = 0;
452	bltData.src_right = fbnode->width;
453	bltData.src_bottom = fbnode->height;
454	bltData.srcFormat = SURF_BGRA8888;
455	bltData.srcMemBase = STMFBGP_FRAMEBUFFER;
456
457	bltData.dstOffset = 0;
458	bltData.dstPitch = fb->pitch;
459	bltData.dst_left = status.leftoffset;
460	bltData.dst_top = status.topoffset;
461	if(mode3d == 1)
462	bltData.dst_right = (fb->width - status.rightoffset) / 2;
463	else
464	bltData.dst_right = fb->width - status.rightoffset;
465	if(mode3d == 2)
466	bltData.dst_bottom = (fb->height - status.bottomoffset) / 2;
467	else
468	bltData.dst_bottom = fb->height - status.bottomoffset;
469	bltData.dstFormat = SURF_BGRA8888;
470	bltData.dstMemBase = STMFBGP_FRAMEBUFFER;
471
472	if(flag == 1 && status.screenanim > 0 && mode3d == 0)
473	{
474	int width = (fb->width - status.rightoffset) - status.leftoffset;
475	int height = (fb->height - status.topoffset) - status.bottomoffset;
476	max = 25;
477	if(status.screenanim == 1 \|\| status.screenanim == 3)
478	{
479	bltData.dst_left = (width / 2) - 1;
480	bltData.dst_right = (width / 2) + 1;
481	}
482	if(status.screenanim == 2 \|\| status.screenanim == 3)
483	{
484	bltData.dst_top = (height / 2) - 1;
485	bltData.dst_bottom = (height / 2) + 1;
486	}
487	wstep = width / max;
488	hstep = height / max;
489	}
490
491	for(i = 0; i < max; i++)
492	{
493
494	if(status.screenanim == 1 \|\| status.screenanim == 3)
495	{
496	int tmpleft = bltData.dst_left - wstep;
497	int tmpright = bltData.dst_right + wstep;
498	if(tmpleft < status.leftoffset)
499	tmpleft = status.leftoffset;
500	if(tmpright > fb->width - status.rightoffset)
501	tmpright = fb->width - status.rightoffset;
502	bltData.dst_left = tmpleft;
503	bltData.dst_right = tmpright;
504	}
505
506	if(status.screenanim == 2 \|\| status.screenanim == 3)
507	{
508	int tmptop = bltData.dst_top - hstep;
509	int tmpbottom = bltData.dst_bottom + hstep;
510	if(tmptop < status.topoffset)
511	tmptop = status.topoffset;
512	if(tmpbottom > fb->height - status.bottomoffset)
513	tmpbottom = fb->height - status.bottomoffset;
514	bltData.dst_top = tmptop;
515	bltData.dst_bottom = tmpbottom;
516	}
517
518	if(status.screenanim > 0) usleep(status.screenanimspeed * 1000);
519
520	if (ioctl(fb->fd, STMFBIO_BLT, &bltData) < 0)
521	{
522	perr("ioctl STMFBIO_BLT");
523	}
524	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
525	{
526	perr("ioctl STMFBIO_SYNC_BLITTER");
527	}
528
529	if(mode3d != 0)
530	{
531	if(mode3d == 1)
532	bltData.dst_left = 0 + status.leftoffset + ((fb->width - status.rightoffset) / 2);
533	if(mode3d == 2)
534	bltData.dst_top = 0 + status.topoffset + ((fb->height - status.bottomoffset) / 2);
535	bltData.dst_right = fb->width - status.rightoffset;
536	bltData.dst_bottom = fb->height - status.bottomoffset;
537
538	if (ioctl(fb->fd, STMFBIO_BLT, &bltData) < 0)
539	{
540	perr("ioctl STMFBIO_BLT");
541	}
542	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
543	{
544	perr("ioctl STMFBIO_SYNC_BLITTER");
545	}
546	}
547	}
548	#else
549	#ifdef NOFB
550	if(status.rguidfd > -1)
551	{
552	char* buf = NULL;
553	buf = scale(fbnode->fb, fbnode->width, fbnode->height, 4, 320, 240, 0);
554	if(buf != NULL)
555	{
556	socksend(&status.rguidfd, (unsigned char)buf, 320 240 * 4, 5000 * 1000);
557	free(buf); buf = NULL;
558	}
559	}
560	if(status.write_png == 1 && status.infobaraktiv == 0)
561	{
562	char* buf = NULL;
563	buf = scale(fbnode->fb, fbnode->width, fbnode->height, 4, 320, 240, 0);
564	if(buf != NULL)
565	{
566	if(writeFBfile.ActBuf == NULL)
567	{
568	writeFBfile.buf1 = malloc(4 * 320 * 240);
569	writeFBfile.ActBuf = writeFBfile.buf1;
570	memcpy(writeFBfile.buf1, (unsigned char)buf, 4 320 * 240);
571	addtimer(&fb2png_thread, START, 10000, 1, NULL, NULL, NULL);
572	}
573	else if(writeFBfile.buf1 == writeFBfile.ActBuf)
574	{
575	if(writeFBfile.buf2 == NULL)
576	writeFBfile.buf2 = malloc(4 * 320 * 240);
577	memcpy(writeFBfile.buf2, (unsigned char)buf, 4 320 * 240);
578	}
579	else if(writeFBfile.buf2 == writeFBfile.ActBuf)
580	{
581	if(writeFBfile.buf1 == NULL)
582	writeFBfile.buf1 = malloc(4 * 320 * 240);
583	memcpy(writeFBfile.buf1, (unsigned char)buf, 4 320 * 240);
584	}
585	//fb2png((unsigned char*)buf, 320, 240, "/tmp/titanlcd.png");
586	free(buf); buf = NULL;
587	}
588	}
589
590	if(fbnode != fb)
591	{
592	for(i = 0; i < fbnode->height; i++)
593	{
594	memcpy(fb->fb + (i * fb->pitch), fbnode->fb + (i * fbnode->pitch), fbnode->width * fbnode->colbytes);
595	}
596	}
597	system("killall -9 xloadimage");
598
599	FILE *fd;
600	fd=fopen("titan.png", "w");
601	fwrite(fb->fb, fb->varfbsize, 1, fd);
602	fclose(fd);
603
604	system("fbgrab -f titan.png -w 1280 -h 720 -b 32 titan1.png > /dev/null");
605	system("xloadimage titan1.png > /dev/null &");
606	#endif
607	#endif
608	*/
609	}
610
611	void setfbtransparent(int value)
612	{
613	char* transparentdev;
614
615	transparentdev = getconfig("transparentdev", NULL);
616
617	if(transparentdev != NULL /&& checkdev(transparentdev)/)
618	{
619	debug(100, "set %s to %d", transparentdev, value);
620	writesysint(transparentdev, value, 1);
621	return;
622	}
623	/*
624	#ifndef SIMULATE
625	struct stmfbio_var_screeninfo_ex varEx = {0};
626
627	varEx.layerid = 0;
628	varEx.activate = STMFBIO_ACTIVATE_IMMEDIATE;
629	varEx.caps = STMFBIO_VAR_CAPS_OPACITY;
630	varEx.opacity = value;
631
632
633	if(ioctl(fb->fd, STMFBIO_SET_VAR_SCREENINFO_EX, &varEx) < 0)
634	perr("STMFBIO_SET_VAR_SCREENINFO_EX");
635	#endif
636	*/
637	}
638
639	int allocbpamem(size_t size, int memfd, unsigned char *mem)
640	{
641	return -1;
642	}
643
644	void freebpamem(int memfd, unsigned char* mem, size_t len)
645	{
646	}
647
648	//mode 0: with fill (draw to skinfb)
649	//mode 1: without fill (draw to skinfb)
650	//mode 2: with fill (draw to fb)
651	//mode 3: without fill (draw to fb)
652	void blitrect(int posx, int posy, int width, int height, long color, int transparent, int mode)
653	{
654	int y, x;
655	unsigned long tmpcol;
656	struct fb* tmpfb = NULL;
657
658	if(posx < 0) posx = 0;
659	if(posy < 0) posy = 0;
660	if(mode < 2)
661	tmpfb = skinfb;
662	else
663	tmpfb = fb;
664
665	if(posx > tmpfb->width) posx = tmpfb->width;
666	if(posy > tmpfb->height) posy = tmpfb->height;
667	if(posx + width > tmpfb->width) width = tmpfb->width - posx;
668	if(posy + height > tmpfb->height) height = tmpfb->height - posy;
669
670	if(width <= 0 \|\| height <= 0) return;
671
672	transparent = (transparent - 255) * -1;
673	tmpcol = color \| ((transparent & 0xff) << 24);
674
675	if(mode == 0 \|\| mode == 2)
676	{
677
678	if(status.bcm == 1 && tmpfb->data_phys != 0)
679	{
680	bcm_accel_fill(tmpfb->data_phys, tmpfb->width, tmpfb->height, tmpfb->pitch, posx, posy, width, height, tmpcol);
681	}
682	else
683	{
684	int yend = (posy + height) * tmpfb->width;
685	posy *= tmpfb->width;
686	int xend = posx + width;
687	// int xlen = (xend - posx) * tmpfb->colbytes;
688	int r = 0;
689	unsigned char* from = tmpfb->fb + (posy + posx) * tmpfb->colbytes;
690
691	for(y = posy; y < yend; y += tmpfb->width)
692	{
693	if(r == 0)
694	{
695	r = 1;
696	for(x = posx; x < xend; x++)
697	drawpixelfastfb(tmpfb, x, y, tmpcol);
698	}
699	else
700	{
701	//memcpy(tmpfb->fb + (y + posx) * tmpfb->colbytes, from, xlen);
702	memcpy_area(tmpfb->fb + (y + posx) * tmpfb->colbytes, from, posx * 4, height-1, width4, tmpfb->width4);
703	y = yend;
704	}
705
706	}
707	}
708	}
709	else if(mode == 1 \|\| mode == 3)
710	{
711	//topline
712	for(x = 0; x < width; x++)
713	drawpixelfb(tmpfb, posx + x, posy, tmpcol);
714	//bottomline
715	for(x = 0; x < width; x++)
716	drawpixelfb(tmpfb, posx + x, posy + height - 1, tmpcol);
717	//leftline
718	for(y = 0; y < height; y++)
719	drawpixelfb(tmpfb, posx, posy + y, tmpcol);
720	//rightline
721	for(y = 0; y < height; y++)
722	drawpixelfb(tmpfb, posx + width - 1, posy + y, tmpcol);
723	}
724
725	/*
726	unsigned long tmpcol;
727
728	transparent = (transparent - 255) * -1;
729	tmpcol = color \| ((transparent & 0xff) << 24);
730
731	STMFBIO_BLT_DATA bltData;
732	memset(&bltData, 0, sizeof(STMFBIO_BLT_DATA));
733
734	if(posx < 0) posx = 0;
735	if(posy < 0) posy = 0;
736	if(mode < 2)
737	{
738	if(posx > skinfb->width) posx = skinfb->width;
739	if(posy > skinfb->height) posy = skinfb->height;
740	if(posx + width > skinfb->width) width = skinfb->width - posx;
741	if(posy + height > skinfb->height) height = skinfb->height - posy;
742	}
743	else
744	{
745	if(posx > fb->width) posx = fb->width;
746	if(posy > fb->height) posy = fb->height;
747	if(posx + width > fb->width) width = fb->width - posx;
748	if(posy + height > fb->height) height = fb->height - posy;
749	}
750
751	if(width <= 0 \|\| height <= 0) return;
752
753	if(mode == 0 \|\| mode == 2)
754	bltData.operation = BLT_OP_FILL;
755	else if(mode == 1 \|\| mode == 3)
756	bltData.operation = BLT_OP_DRAW_RECTANGLE;
757	bltData.colour = tmpcol;
758	bltData.srcFormat = SURF_ARGB8888;
759	bltData.srcMemBase = STMFBGP_FRAMEBUFFER;
760
761	if(status.usedirectfb == 1)
762	bltData.dstOffset = 0;
763	else
764	{
765	if(mode < 2)
766	bltData.dstOffset = fb->varfbsize;
767	else
768	bltData.dstOffset = 0;
769	}
770	if(mode < 2)
771	bltData.dstPitch = skinfb->pitch;
772	else
773	bltData.dstPitch = fb->pitch;
774	bltData.dst_top = posy;
775	bltData.dst_left = posx;
776	bltData.dst_bottom = posy + height;
777	bltData.dst_right = posx + width;
778	bltData.dstFormat = SURF_ARGB8888;
779	bltData.dstMemBase = STMFBGP_FRAMEBUFFER;
780
781	if(ioctl(fb->fd, STMFBIO_BLT, &bltData) < 0)
782	{
783	perr("ioctl STMFBIO_BLT");
784	}
785	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
786	{
787	perr("ioctl STMFBIO_SYNC_BLITTER");
788	}
789	*/
790	}
791
792	int readjpg(const char* filename, unsigned long* width, unsigned long* height, unsigned long* rowbytes, int* channels, unsigned char *mem, int memfd)
793	{
794	/*
795	#ifndef SIMULATE
796	FILE *fp;
797	unsigned int temp1, temp2;
798
799	if(filename == NULL) return -1;
800
801	debug(200, "hardware decode picture (%s)...", filename);
802
803	if (!(fp = fopen(filename, "rb")))
804	return -1;
805
806	if(get_jpeg_img_size(fp, &temp1, &temp2) != LIBMMEIMG_SUCCESS)
807	return -1;
808
809	*width = temp1;
810	*height = temp2;
811	*channels = 3;
812	rowbytes = channels * temp1;
813
814	if(allocbpamem(temp1 * temp2 * (*channels), memfd, mem) != 0)
815	{
816	fclose(fp);
817	return -1;
818	}
819
820	if(decode_jpeg_noalloc(fp, temp1, temp2, temp1, temp2, (char )mem, 1) == LIBMMEIMG_SUCCESS)
821	{
822	fclose(fp);
823	return 0;
824	}
825
826	fclose(fp);
827	freebpamem(memfd, mem, temp1 * temp2 * (*channels));
828	err("hardware decode error");
829	#endif
830	return -1;
831	*/
832	return -1;
833	}
834
835	//flag 0: blit from accelfb to skinfb
836	//flag 1: blit from skinfb to accelfb
837	void blitscale(int posx, int posy, int width, int height, int scalewidth, int scaleheight, int flag)
838	{
839	#ifndef SIMULATE
840	//#ifdef BLITHELP
841	unsigned char *source = NULL;
842	unsigned char *target = NULL;
843	int zpitch = 0;
844	int zheight = 0;
845	int zwidth = 0;
846	int qpitch = 0;
847	int qheight = 0;
848	int qwidth = 0;
849	unsigned long source_phys = 0;
850	unsigned long target_phys = 0;
851
852	if(scalewidth == 0) scalewidth = width;
853	if(scaleheight == 0) scaleheight = height;
854
855	if(posx < 0) posx = 0;
856	if(posx > skinfb->width) posx = skinfb->width;
857	if(posy < 0) posy = 0;
858	if(posy > skinfb->height) posy = skinfb->height;
859	if(posx + scalewidth > skinfb->width) scalewidth = skinfb->width - posx;
860	if(posy + scaleheight > skinfb->height) scaleheight = skinfb->height - posy;
861
862	if(width <= 0 \|\| height <= 0 \|\| scalewidth <= 0 \|\| scaleheight <= 0) return;
863
864	if(flag == 1 && (scalewidth * scaleheight * 4) > accelfb->varfbsize)
865	{
866	err("accelfb to small %d -> %lu ", scalewidth * scaleheight * 4, accelfb->varfbsize);
867	return;
868	}
869	if(flag == 0)
870	{
871	source = accelfb->fb;
872	source_phys = accelfb->data_phys;
873	target_phys = skinfb->data_phys;
874
875	target = skinfb->fb + (posy * skinfb->pitch) + (posx*4);
876	zpitch = skinfb->pitch;
877	zheight = skinfb->height;
878	zwidth = skinfb->width;
879	qpitch = width*4;
880	qheight = height;
881	qwidth = width;
882	}
883	else
884	{
885	source = skinfb->fb;
886	source_phys = skinfb->data_phys;
887	target_phys = accelfb->data_phys;
888
889	target = accelfb->fb + (posy * accelfb->pitch) + (posx*4);
890	zpitch = accelfb->pitch;
891	zheight = accelfb->height;
892	zwidth = accelfb->width;
893	qpitch = width*4;
894	qheight = height;
895	qwidth = width;
896	}
897
898	if(status.bcm == 1 && source_phys > 0 && target_phys >0)
899	{
900	bcm_accel_blit(source_phys, qwidth, qheight, qpitch, 0, target_phys, zwidth, zheight, zpitch, 0, 0, width, height, posx, posy, scalewidth, scaleheight, 0, 0);
901	flag = 1;
902	}
903	else
904	{
905	unsigned char *helpbuf = NULL;
906	helpbuf = scale(source, width, height, 4, scalewidth, scaleheight, 0);
907
908	size_t helpb = 0;
909	size_t helpz = 0;
910	size_t help = 0;
911
912	while(helpz < scaleheight && helpz < (zheight - posy)) {
913	//memcpy(target[help], helpbuf[helpb], scalewidth*4);
914	memcpy(target+help, helpbuf+helpb, scalewidth*4);
915	help = help + zpitch;
916	helpb = helpb + scalewidth*4;
917	helpz = helpz + 1;
918	}
919	free(helpbuf);
920	}
921
922
923	if(flag == 0)
924	blit();
925
926	//#endif
927
928	/*
929	STMFBIO_BLT_DATA blt_data;
930	memset(&blt_data, 0, sizeof(STMFBIO_BLT_DATA));
931
932	if(scalewidth == 0) scalewidth = width;
933	if(scaleheight == 0) scaleheight = height;
934
935	if(posx < 0) posx = 0;
936	if(posx > skinfb->width) posx = skinfb->width;
937	if(posy < 0) posy = 0;
938	if(posy > skinfb->height) posy = skinfb->height;
939	if(posx + scalewidth > skinfb->width) scalewidth = skinfb->width - posx;
940	if(posy + scaleheight > skinfb->height) scaleheight = skinfb->height - posy;
941
942	if(width <= 0 \|\| height <= 0 \|\| scalewidth <= 0 \|\| scaleheight <= 0) return;
943
944	if(flag == 1 && (scalewidth * scaleheight * 4) > accelfb->varfbsize)
945	{
946	err("accelfb to small %d -> %lu ", scalewidth * scaleheight * 4, accelfb->varfbsize);
947	return;
948	}
949
950	blt_data.operation = BLT_OP_COPY;
951
952	if(flag == 0)
953	{
954	if(status.usedirectfb == 1)
955	blt_data.srcOffset = fb->varfbsize;
956	else
957	blt_data.srcOffset = fb->varfbsize + skinfb->varfbsize;
958	}
959	else
960	{
961	if(status.usedirectfb == 1)
962	blt_data.srcOffset = 0;
963	else
964	blt_data.srcOffset = fb->varfbsize;
965	}
966
967	blt_data.srcPitch = width * 4;
968	blt_data.src_top = 0;
969	blt_data.src_left = 0;
970	blt_data.src_right = width;
971	blt_data.src_bottom = height;
972	blt_data.srcFormat = SURF_ARGB8888;
973	blt_data.srcMemBase = STMFBGP_FRAMEBUFFER;
974
975	if(flag == 0)
976	{
977	if(status.usedirectfb == 1)
978	{
979	blt_data.dstOffset = 0;
980	blt_data.dstPitch = fb->pitch;
981	}
982	else
983	{
984	blt_data.dstOffset = fb->varfbsize;
985	blt_data.dstPitch = skinfb->pitch;
986	}
987	}
988	else
989	{
990	if(status.usedirectfb == 1)
991	{
992	blt_data.dstOffset = fb->varfbsize;
993	blt_data.dstPitch = skinfb->pitch;
994	}
995	else
996	{
997	blt_data.dstOffset = fb->varfbsize + skinfb->varfbsize;
998	blt_data.dstPitch = scalewidth * 4;
999	}
1000	}
1001
1002	blt_data.dst_left = posx;
1003	blt_data.dst_top = posy;
1004	blt_data.dst_right = posx + scalewidth;
1005	blt_data.dst_bottom = posy + scaleheight;
1006	blt_data.dstFormat = SURF_ARGB8888;
1007	blt_data.dstMemBase = STMFBGP_FRAMEBUFFER;
1008
1009	if (ioctl(fb->fd, STMFBIO_BLT, &blt_data) < 0)
1010	{
1011	perr("ioctl STMFBIO_BLT");
1012	}
1013	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
1014	{
1015	perr("ioctl STMFBIO_SYNC_BLITTER");
1016	}
1017	*/
1018	#endif
1019	}
1020
1021	void blitjpg(unsigned char* buf, int posx, int posy, int width, int height, int scalewidth, int scaleheight, int mwidth, int mheight, int halign, int valign)
1022	//void blitjpg(unsigned char* buf, int posx, int posy, int width, int height, int scalewidth, int scaleheight)
1023	{
1024	#ifndef SIMULATE
1025	#ifdef BLITHELP
1026	unsigned char *helpbuf = NULL;
1027	unsigned char *framebuf = NULL;
1028
1029	if(scalewidth != 0 \|\| scaleheight != 0) {
1030	helpbuf = scale(buf, width, height, 3, scalewidth, scaleheight, 1);
1031	if(helpbuf == NULL)
1032	return;
1033	}
1034	else {
1035	helpbuf = buf;
1036	scalewidth = width;
1037	scaleheight = height;
1038	}
1039	size_t helpb = 0;
1040	size_t helpz = 0;
1041	size_t help = 0;
1042
1043	framebuf = skinfb->fb;
1044	framebuf = framebuf + (posy * skinfb->pitch) + (posx*4);
1045
1046	while(helpz < scaleheight && helpz < (skinfb->height - posy)) {
1047	help = 0;
1048	while(help < (scalewidth4) && help < (skinfb->pitch - (posx4))) {
1049	framebuf[help+0] = helpbuf[helpb+2];
1050	framebuf[help+1] = helpbuf[helpb+1];
1051	framebuf[help+2] = helpbuf[helpb+0];
1052	framebuf[help+3] = 0xff;
1053	help = help + 4;
1054	helpb = helpb + 3;
1055	}
1056	if(help >= (skinfb->pitch - (posx*4)))
1057	helpb = (helpz+1) * (scalewidth*3);
1058	framebuf = framebuf + skinfb->pitch;
1059	helpz = helpz + 1;
1060	}
1061	free(helpbuf);
1062	blit();
1063	#endif
1064
1065	/*
1066	STMFBIO_BLT_EXTERN_DATA blt_data;
1067	memset(&blt_data, 0, sizeof(STMFBIO_BLT_EXTERN_DATA));
1068
1069	blt_data.operation = BLT_OP_COPY;
1070	blt_data.ulFlags = 0;
1071	blt_data.srcOffset = 0;
1072	blt_data.srcPitch = width * 3;
1073	blt_data.dstOffset = 0;
1074	blt_data.dstPitch = skinfb->pitch;
1075	blt_data.src_top = 0;
1076	blt_data.src_left = 0;
1077	blt_data.src_right = width;
1078	blt_data.src_bottom = height;
1079	blt_data.dst_left = posx;
1080	blt_data.dst_top = posy;
1081
1082	if(scalewidth == 0) scalewidth = width;
1083	if(scaleheight == 0) scaleheight = height;
1084
1085	blt_data.dst_right = posx + scalewidth;
1086	blt_data.dst_bottom = posy + scaleheight;
1087	blt_data.srcFormat = SURF_BGR888;
1088	blt_data.dstFormat = SURF_ARGB8888;
1089	blt_data.srcMemBase = (char *)buf;
1090	blt_data.dstMemBase = (char *)skinfb->fb;
1091	blt_data.srcMemSize = width * height * 3;
1092	blt_data.dstMemSize = skinfb->pitch * skinfb->height;
1093
1094	if(ioctl(skinfb->fd, STMFBIO_BLT_EXTERN, &blt_data) < 0)
1095	{
1096	err("ioctl STMFBIO_BLT_EXTERN");
1097	}
1098	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
1099	{
1100	perr("ioctl STMFBIO_SYNC_BLITTER");
1101	}
1102	*/
1103
1104	#endif
1105	}
1106
1107	void initsignal(struct sigaction* sa)
1108	{
1109	sigaction(SIGILL, sa, NULL);
1110	sigaction(SIGBUS, sa, NULL);
1111	sigaction(SIGFPE, sa, NULL);
1112	sigaction(SIGUSR1, sa, NULL);
1113	sigaction(SIGSEGV, sa, NULL);
1114	sigaction(SIGUSR2, sa, NULL);
1115	sigaction(SIGPIPE, sa, NULL);
1116	sigaction(SIGALRM, sa, NULL);
1117	// sigaction(SIGSTKFLT, sa, NULL);
1118	sigaction(SIGABRT, sa, NULL);
1119
1120	signal(SIGHUP, SIG_IGN);
1121	signal(SIGINT, SIG_IGN);
1122	signal(SIGTRAP, SIG_IGN);
1123	signal(SIGXCPU, SIG_IGN);
1124	signal(SIGXFSZ, SIG_IGN);
1125	signal(SIGVTALRM, SIG_IGN);
1126	signal(SIGPROF, SIG_IGN);
1127	signal(SIGPOLL, SIG_IGN);
1128	signal(SIGRTMAX, SIG_IGN);
1129	signal(SIGPWR, SIG_IGN);
1130	signal(SIGSYS, SIG_IGN);
1131	}
1132
1133	void sighandler(int sig, struct sigcontext ctx)
1134	{
1135	switch(sig)
1136	{
1137	case SIGALRM:
1138	{
1139	err("got signal sigalrm but ignore it");
1140	break;
1141	}
1142	case SIGPIPE:
1143	{
1144	err("got signal sigpipe but ignore it");
1145	break;
1146	}
1147	case SIGUSR1:
1148	{
1149	//todo all configs
1150	reloadconfig(status.configfile);
1151	reloadconfig(getconfig("ownconfig", NULL));
1152	break;
1153	}
1154	case SIGUSR2: //called if hanging mainthread detect
1155	{
1156	debugstack(sig, NULL, NULL);
1157	break;
1158	}
1159	case SIGILL:
1160	case SIGBUS:
1161	case SIGFPE:
1162	case SIGSEGV:
1163	// case SIGSTKFLT:
1164	{
1165	/*
1166	#ifdef SIMULATE
1167	//intel
1168	debugstack((void *)ctx.eip, NULL);
1169	err("got signal %d, fault address 0x%lx from 0x%lx", sig, ctx.cr2, ctx.eip);
1170	#else
1171	// sh4
1172	//unsigned long sc_regs[16];
1173	//unsigned long sc_pc; //programm counter register
1174	//unsigned long sc_pr; //procedure register
1175	//unsigned long sc_sr; //status register
1176	//unsigned long sc_gbr;
1177	//unsigned long sc_mach;
1178	//unsigned long sc_macl;
1179
1180	debugstack(sig, (void )ctx.sc_pr, (void )ctx.sc_pc);
1181	err("got signal %d (%s), programm counter reg: 0x%lx, procedure reg: 0x%lx", sig, strsignal(sig), ctx.sc_pc, ctx.sc_pr);
1182	#endif
1183	*/
1184	if(getconfigint("saverun", NULL) == 1 && status.longjumpbuf != NULL)
1185	siglongjmp(status.longjumpbuf, 999);
1186	else
1187	exit(100);
1188	break;
1189	}
1190	}
1191	}
1192
1193	int setvmpeg(struct dvbdev* node, int value, int flag)
1194	{
1195	debug(4440, "in");
1196	char* vmpegdev = NULL, tmpstr = NULL, buf = NULL;
1197	int ret = 0;
1198
1199	if(node == NULL) return 1;
1200	if(flag == 0) vmpegdev = getconfig("vmpegleftdev", NULL);
1201	if(flag == 1) vmpegdev = getconfig("vmpegtopdev", NULL);
1202	if(flag == 2) vmpegdev = getconfig("vmpegwidthdev", NULL);
1203	if(flag == 3) vmpegdev = getconfig("vmpegheightdev", NULL);
1204	if(flag == 99) vmpegdev = getconfig("vmpegapplydev", NULL);
1205
1206	if(vmpegdev != NULL)
1207	{
1208	buf = malloc(MINMALLOC);
1209	if(buf == NULL)
1210	{
1211	err("no mem");
1212	return 1;
1213	}
1214
1215	tmpstr = malloc(10);
1216	if(tmpstr == NULL)
1217	{
1218	err("no mem");
1219	free(buf);
1220	return 1;
1221	}
1222
1223	snprintf(buf, MINMALLOC, vmpegdev, node->devnr);
1224	snprintf(tmpstr, 10, "%x", value);
1225	debug(444, "set %s to %s", buf, tmpstr);
1226	status.tvpic = 1;
1227	ret = writesys(buf, tmpstr, 1);
1228
1229	free(tmpstr);
1230	free(buf);
1231	return ret;
1232	}
1233
1234	debug(4440, "out");
1235	return 0;
1236	}
1237
1238	//flag 0: wh = width
1239	//flag 1: wh = height
1240	int setvmpegrect(struct dvbdev* node, int left, int top, int wh, int flag)
1241	{
1242	int ret = 0;
1243
1244	ret = setvmpeg(node, left, 0);
1245	ret = setvmpeg(node, top, 1);
1246
1247	if(flag == 0)
1248	{
1249	ret = setvmpeg(node, wh, 2);
1250	ret = setvmpeg(node, wh / 1.4, 3);
1251	}
1252	if(flag == 1)
1253	{
1254	ret = setvmpeg(node, wh, 3);
1255	ret = setvmpeg(node, wh * 1.3, 2);
1256	}
1257
1258	setvmpeg(node, 0, 99);
1259
1260	return ret;
1261	}
1262
1263	int resetvmpeg(struct dvbdev* node)
1264	{
1265	int ret = 0;
1266
1267	ret = setvmpeg(node, 0, 0);
1268	ret = setvmpeg(node, 0, 1);
1269	ret = setvmpeg(node, 0, 2);
1270	ret = setvmpeg(node, 0, 3);
1271
1272	ret = setvmpeg(node, 0, 99);
1273
1274	status.tvpic = 0;
1275
1276	return ret;
1277	}
1278
1279	int resettvpic()
1280	{
1281	/*
1282	if(status.tvpic == 1 && status.aktservice != NULL)
1283	{
1284	status.tvpic = 0;
1285	resetvmpeg(status.aktservice->videodev);
1286	}
1287	*/
1288	int ret = 0;
1289
1290	if(status.tvpic > 0 && status.aktservice != NULL)
1291	ret = resetvmpeg(status.aktservice->videodev);
1292
1293	return ret;
1294	}
1295
1296	int cagetslotinfo(struct dvbdev* node, ca_slot_info_t* info)
1297	{
1298	int ret = 0;
1299
1300	if(node == NULL \|\| info == NULL)
1301	{
1302	err("NULL detect");
1303	return 1;
1304	}
1305
1306	struct pollfd fds;
1307
1308	fds.fd = node->fd;
1309	fds.events = POLLOUT \| POLLPRI \| POLLIN;
1310
1311	info->flags = 0;
1312
1313	ret = TEMP_FAILURE_RETRY(poll(&fds, 1, 1000));
1314
1315	if(ret < 0)
1316	{
1317	err("poll data");
1318	return 1; //error
1319	}
1320	else if(ret == 0)
1321	return 0; //timeout
1322	else if(ret > 0)
1323	{
1324	if(fds.revents & POLLOUT)
1325	info->flags = CA_CI_MODULE_READY;
1326	if(fds.revents & POLLIN)
1327	info->flags = CA_CI_MODULE_READY;
1328	if(fds.revents & POLLPRI)
1329	info->flags = 0;
1330	}
1331
1332	return 0;
1333	}
1334
1335	void memcpy_word(char* dest, char* src, long anzw)
1336	{
1337	// Folgende Werte m�ssen volatile definiert sein
1338	// char* memcpy_word_src ---> pointer Quelle
1339	// char* memcpy_word_dest ---> pointer Ziehl
1340	// long memcpy_word_anzw ---> Anzahl der W�rter (4 byte) die kopiert werden sollen.
1341
1342	memcpy_word_src = src;
1343	memcpy_word_dest = dest;
1344	memcpy_word_anzw = anzw;
1345
1346	#ifndef ARM
1347	asm(
1348	" lw $8, memcpy_word_src \n"
1349	" lw $9, memcpy_word_dest \n"
1350	" lw $10, memcpy_word_anzw \n"
1351	" addi $10, $10, -1 \n"
1352	"loop1: \n"
1353	" lw $11, ($8) \n"
1354	" sw $11, ($9) \n"
1355	" addi $8, $8, 4 \n"
1356	" addi $9, $9, 4 \n"
1357	" addi $10, $10, -1 \n"
1358	" bgez $10, loop1 \n"
1359	);
1360	#endif
1361
1362	}
1363
1364	void memcpy_byte(char* dest, char* src, long anzb)
1365	{
1366	// Folgende Werte m�ssen volatile definiert sein
1367	// char* memcpy_byte_src ---> pointer Quelle
1368	// char* memcpy_byte_dest ---> pointer Ziehl
1369	// long memcpy_byte_anzb ---> Anzahl bytes die kopiert werden sollen.
1370
1371	memcpy_byte_src = src;
1372	memcpy_byte_dest = dest;
1373	memcpy_byte_anzb = anzb;
1374
1375	#ifndef ARM
1376	asm (
1377	" li $12, 4 \n"
1378	" lw $8, memcpy_byte_src \n"
1379	" lw $9, memcpy_byte_dest \n"
1380	" lw $10, memcpy_byte_anzb \n"
1381	"word: \n"
1382	" bltu $10, $12, byte \n"
1383	" lw $11, ($8) \n"
1384	" sw $11, ($9) \n"
1385	" addi $8, $8, 4 \n"
1386	" addi $9, $9, 4 \n"
1387	" addi $10, $10, -4 \n"
1388	" b word \n"
1389	"byte: \n"
1390	" beqz $10, end \n"
1391	" lb $11, ($8) \n"
1392	" sb $11, ($9) \n"
1393	" addi $8, $8, 1 \n"
1394	" addi $9, $9, 1 \n"
1395	" addi $10, $10, -1 \n"
1396	" b byte \n"
1397	"end: \n"
1398	" nop \n"
1399	);
1400	#endif
1401	}
1402
1403
1404	void memcpy_area(unsigned char* targetADDR, unsigned char* startADDR, long pxAbs, long hight, long widthAbs, long FBwidthAbs)
1405	{
1406
1407	#ifndef ARM
1408	asm(
1409
1410	" lw $t3, %[targetADDR] \n"
1411	" lw $t4, %[startADDR] \n"
1412	" lw $t5, %[pxAbs] \n"
1413	" lw $t6, %[widthAbs] \n"
1414	" lw $t7, %[FBwidthAbs] \n"
1415	" lw $t8, %[hight] \n"
1416
1417	" move $t0, $t4 # Temp-startADDR \n"
1418	" move $t1, $t6 # Temp-widthAbs \n"
1419	" add $t2, $t5, $t6 \n"
1420	" sub $t7, $t7, $t2 # Diff withAbs und FBwidthAbs \n"
1421
1422	"p3NewLine2: \n"
1423	" beqz $t8, p3End \n"
1424	"p3NextWord: \n"
1425	" beqz $t1, p3NewLine1 \n"
1426	" lw $t9, ($t0) \n"
1427	" sw $t9, ($t3) \n"
1428	" addi $t0, 4 \n"
1429	" addi $t3, 4 \n"
1430	" addi $t1, -4 \n"
1431	" b p3NextWord \n"
1432
1433
1434	"p3NewLine1: \n"
1435	" move $t0, $t4 \n"
1436	" move $t1, $t6 \n"
1437	" add $t3, $t3, $t7 \n"
1438	" add $t3, $t3, $t5 \n"
1439	" addi $t8, -1 \n"
1440	" b p3NewLine2 \n"
1441
1442	"p3End: \n"
1443	" nop \n"
1444	::[targetADDR] "m" (targetADDR), [startADDR] "m" (startADDR), [pxAbs] "m" (pxAbs), [widthAbs] "m" (widthAbs), [FBwidthAbs] "m" (FBwidthAbs), [hight] "m" (hight)
1445	);
1446	#endif
1447
1448	return;
1449	}
1450
1451	int setfbosddev(char* dev, int value)
1452	{
1453	char* tmpstr = NULL;
1454	int ret = 0;
1455
1456	tmpstr = malloc(10);
1457	if(tmpstr == NULL)
1458	{
1459	err("no mem");
1460	return 1;
1461	}
1462
1463	sprintf(tmpstr, "%x", value);
1464	debug(101, "set %s to %s", dev, tmpstr);
1465
1466	if(dev != NULL)
1467	{
1468	ret = writesys(dev, tmpstr, 1);
1469	return ret;
1470	}
1471
1472	return 0;
1473	}
1474
1475	char* getfbosddev(char* dev)
1476	{
1477	char *value = NULL;
1478
1479	if(dev == NULL)
1480	{
1481	err("NULL detect");
1482	return NULL;
1483	}
1484
1485	value = readsys(dev, 1);
1486	if(value == NULL)
1487	{
1488	err("NULL detect");
1489	return NULL;
1490	}
1491
1492	debug(101, "get %s to %s", dev, value);
1493
1494	return value;
1495	}
1496
1497
1498	void setfbosd()
1499	{
1500	debug(101, "################## set osd offset ####################");
1501	debug(101, "status.leftoffset: %d", status.leftoffset);
1502	debug(101, "status.rightoffset: %d", status.rightoffset);
1503	debug(101, "status.topoffset: %d", status.topoffset);
1504	debug(101, "status.bottomoffset: %d", status.bottomoffset);
1505
1506	char* fbleftdev = "/proc/stb/fb/dst_left";
1507	char* fbwidthdev = "/proc/stb/fb/dst_width";
1508	char* fbtopdev = "/proc/stb/fb/dst_top";
1509	char* fbheightdev = "/proc/stb/fb/dst_height";
1510
1511	int fbleft = strtol(getfbosddev(fbleftdev) , NULL, 16);
1512	int fbwidth = strtol(getfbosddev(fbwidthdev) , NULL, 16);
1513	int fbtop = strtol(getfbosddev(fbtopdev) , NULL, 16);
1514	int fbheight = strtol(getfbosddev(fbheightdev) , NULL, 16);
1515	debug(101, "Setting OSD position: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1516
1517	fbleft = status.leftoffset;
1518	fbwidth = 720 - status.leftoffset - status.rightoffset;
1519	fbtop = status.topoffset;
1520	fbheight = 576 - status.topoffset - status.bottomoffset;
1521	debug(101, "Setting OSD position changed: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1522	debug(10, "Setting OSD position changed: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1523
1524	setfbosddev(fbleftdev, fbleft);
1525	setfbosddev(fbwidthdev, fbwidth);
1526	setfbosddev(fbtopdev, fbtop);
1527	setfbosddev(fbheightdev, fbheight);
1528	debug(101, "######################################################");
1529	}
1530
1531	int setrtctimemips()
1532	{
1533	char rtctimedev = NULL, tmpstr = NULL;
1534	int ret = 0;
1535	// int value = 0;
1536
1537	time_t t = time(NULL);
1538	struct tm *local = localtime(&t);
1539	time_t rawlocal = mktime(local);
1540
1541	t = time(NULL);
1542	struct tm *gmt = gmtime(&t);
1543	time_t rawgmt = mktime(gmt);
1544
1545	int offset = difftime(rawlocal, rawgmt);
1546
1547	tmpstr = oitoa(offset);
1548	rtctimedev = getconfig("rtctime_offsetdev", NULL);
1549	if(rtctimedev != NULL)
1550	ret = writesys(rtctimedev, tmpstr, 0);
1551	else
1552	ret = writesys("/proc/stb/fp/rtc_offset", tmpstr, 0);
1553	free(tmpstr); tmpstr = NULL;
1554	rtctimedev = NULL;
1555
1556	if(ret == 0)
1557	{
1558	tmpstr = oitoa(rawlocal);
1559	rtctimedev = getconfig("rtctimedev", NULL);
1560	if(rtctimedev != NULL)
1561	ret = writesys(rtctimedev, tmpstr, 0);
1562	else
1563	ret = writesys("/proc/stb/fp/rtc", tmpstr, 0);
1564	free(tmpstr); tmpstr = NULL;
1565	rtctimedev = NULL;
1566	}
1567	return ret;
1568	}
1569
1570	#endif

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

Download in other formats: