Context Navigation

source: titan/titan/mipselport.h @ 30744

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

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

Download in other formats: