Context Navigation

source: titan/titan/mipselport.h @ 37104

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

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

Download in other formats: