Context Navigation

source: titan/titan/mipselport.h @ 30593

Last change on this file since 30593 was 30593, checked in by obi, 9 years ago
[mipsel] add srt support and firststep for gst prebuffer and fix all compiler warnings
File size: 32.4 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	/*
458	#ifndef SIMULATE
459	struct stmfbio_var_screeninfo_ex varEx = {0};
460
461	varEx.layerid = 0;
462	varEx.activate = STMFBIO_ACTIVATE_IMMEDIATE;
463	varEx.caps = STMFBIO_VAR_CAPS_OPACITY;
464	varEx.opacity = value;
465
466
467	if(ioctl(fb->fd, STMFBIO_SET_VAR_SCREENINFO_EX, &varEx) < 0)
468	perr("STMFBIO_SET_VAR_SCREENINFO_EX");
469	#endif
470	*/
471	}
472
473	int allocbpamem(size_t size, int memfd, unsigned char *mem)
474	{
475	return -1;
476	}
477
478	void freebpamem(int memfd, unsigned char* mem, size_t len)
479	{
480	}
481
482	//mode 0: with fill (draw to skinfb)
483	//mode 1: without fill (draw to skinfb)
484	//mode 2: with fill (draw to fb)
485	//mode 3: without fill (draw to fb)
486	void blitrect(int posx, int posy, int width, int height, long color, int transparent, int mode)
487	{
488	int y, x;
489	unsigned long tmpcol;
490	struct fb* tmpfb = NULL;
491
492	if(posx < 0) posx = 0;
493	if(posy < 0) posy = 0;
494	if(mode < 2)
495	tmpfb = skinfb;
496	else
497	tmpfb = fb;
498
499	if(posx > tmpfb->width) posx = tmpfb->width;
500	if(posy > tmpfb->height) posy = tmpfb->height;
501	if(posx + width > tmpfb->width) width = tmpfb->width - posx;
502	if(posy + height > tmpfb->height) height = tmpfb->height - posy;
503
504	if(width <= 0 \|\| height <= 0) return;
505
506	transparent = (transparent - 255) * -1;
507	tmpcol = color \| ((transparent & 0xff) << 24);
508
509	if(mode == 0 \|\| mode == 2)
510	{
511	int yend = (posy + height) * tmpfb->width;
512	posy *= tmpfb->width;
513	int xend = posx + width;
514	// int xlen = (xend - posx) * tmpfb->colbytes;
515	int r = 0;
516	unsigned char* from = tmpfb->fb + (posy + posx) * tmpfb->colbytes;
517
518	for(y = posy; y < yend; y += tmpfb->width)
519	{
520	if(r == 0)
521	{
522	r = 1;
523	for(x = posx; x < xend; x++)
524	drawpixelfastfb(tmpfb, x, y, tmpcol);
525	}
526	else
527	{
528	//memcpy(tmpfb->fb + (y + posx) * tmpfb->colbytes, from, xlen);
529	memcpy_area(tmpfb->fb + (y + posx) * tmpfb->colbytes, from, posx * 4, height-1, width4, tmpfb->width4);
530	y = yend;
531	}
532
533	}
534	}
535	else if(mode == 1 \|\| mode == 3)
536	{
537	//topline
538	for(x = 0; x < width; x++)
539	drawpixelfb(tmpfb, posx + x, posy, tmpcol);
540	//bottomline
541	for(x = 0; x < width; x++)
542	drawpixelfb(tmpfb, posx + x, posy + height - 1, tmpcol);
543	//leftline
544	for(y = 0; y < height; y++)
545	drawpixelfb(tmpfb, posx, posy + y, tmpcol);
546	//rightline
547	for(y = 0; y < height; y++)
548	drawpixelfb(tmpfb, posx + width - 1, posy + y, tmpcol);
549	}
550
551	/*
552	unsigned long tmpcol;
553
554	transparent = (transparent - 255) * -1;
555	tmpcol = color \| ((transparent & 0xff) << 24);
556
557	STMFBIO_BLT_DATA bltData;
558	memset(&bltData, 0, sizeof(STMFBIO_BLT_DATA));
559
560	if(posx < 0) posx = 0;
561	if(posy < 0) posy = 0;
562	if(mode < 2)
563	{
564	if(posx > skinfb->width) posx = skinfb->width;
565	if(posy > skinfb->height) posy = skinfb->height;
566	if(posx + width > skinfb->width) width = skinfb->width - posx;
567	if(posy + height > skinfb->height) height = skinfb->height - posy;
568	}
569	else
570	{
571	if(posx > fb->width) posx = fb->width;
572	if(posy > fb->height) posy = fb->height;
573	if(posx + width > fb->width) width = fb->width - posx;
574	if(posy + height > fb->height) height = fb->height - posy;
575	}
576
577	if(width <= 0 \|\| height <= 0) return;
578
579	if(mode == 0 \|\| mode == 2)
580	bltData.operation = BLT_OP_FILL;
581	else if(mode == 1 \|\| mode == 3)
582	bltData.operation = BLT_OP_DRAW_RECTANGLE;
583	bltData.colour = tmpcol;
584	bltData.srcFormat = SURF_ARGB8888;
585	bltData.srcMemBase = STMFBGP_FRAMEBUFFER;
586
587	if(status.usedirectfb == 1)
588	bltData.dstOffset = 0;
589	else
590	{
591	if(mode < 2)
592	bltData.dstOffset = fb->varfbsize;
593	else
594	bltData.dstOffset = 0;
595	}
596	if(mode < 2)
597	bltData.dstPitch = skinfb->pitch;
598	else
599	bltData.dstPitch = fb->pitch;
600	bltData.dst_top = posy;
601	bltData.dst_left = posx;
602	bltData.dst_bottom = posy + height;
603	bltData.dst_right = posx + width;
604	bltData.dstFormat = SURF_ARGB8888;
605	bltData.dstMemBase = STMFBGP_FRAMEBUFFER;
606
607	if(ioctl(fb->fd, STMFBIO_BLT, &bltData) < 0)
608	{
609	perr("ioctl STMFBIO_BLT");
610	}
611	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
612	{
613	perr("ioctl STMFBIO_SYNC_BLITTER");
614	}
615	*/
616	}
617
618	int readjpg(const char* filename, unsigned long* width, unsigned long* height, unsigned long* rowbytes, int* channels, unsigned char *mem, int memfd)
619	{
620	/*
621	#ifndef SIMULATE
622	FILE *fp;
623	unsigned int temp1, temp2;
624
625	if(filename == NULL) return -1;
626
627	debug(200, "hardware decode picture (%s)...", filename);
628
629	if (!(fp = fopen(filename, "rb")))
630	return -1;
631
632	if(get_jpeg_img_size(fp, &temp1, &temp2) != LIBMMEIMG_SUCCESS)
633	return -1;
634
635	*width = temp1;
636	*height = temp2;
637	*channels = 3;
638	rowbytes = channels * temp1;
639
640	if(allocbpamem(temp1 * temp2 * (*channels), memfd, mem) != 0)
641	{
642	fclose(fp);
643	return -1;
644	}
645
646	if(decode_jpeg_noalloc(fp, temp1, temp2, temp1, temp2, (char )mem, 1) == LIBMMEIMG_SUCCESS)
647	{
648	fclose(fp);
649	return 0;
650	}
651
652	fclose(fp);
653	freebpamem(memfd, mem, temp1 * temp2 * (*channels));
654	err("hardware decode error");
655	#endif
656	return -1;
657	*/
658	return -1;
659	}
660
661	//flag 0: blit from accelfb to skinfb
662	//flag 1: blit from skinfb to accelfb
663	void blitscale(int posx, int posy, int width, int height, int scalewidth, int scaleheight, int flag)
664	{
665	#ifndef SIMULATE
666	#ifdef BLITHELP
667	unsigned char *quelle = NULL;
668	unsigned char *ziehl = NULL;
669	unsigned char *helpbuf = NULL;
670	int zpitch = 0;
671	int zheight = 0;
672
673	if(scalewidth == 0) scalewidth = width;
674	if(scaleheight == 0) scaleheight = height;
675
676	if(posx < 0) posx = 0;
677	if(posx > skinfb->width) posx = skinfb->width;
678	if(posy < 0) posy = 0;
679	if(posy > skinfb->height) posy = skinfb->height;
680	if(posx + scalewidth > skinfb->width) scalewidth = skinfb->width - posx;
681	if(posy + scaleheight > skinfb->height) scaleheight = skinfb->height - posy;
682
683	if(width <= 0 \|\| height <= 0 \|\| scalewidth <= 0 \|\| scaleheight <= 0) return;
684
685	if(flag == 1 && (scalewidth * scaleheight * 4) > accelfb->varfbsize)
686	{
687	err("accelfb to small %d -> %lu ", scalewidth * scaleheight * 4, accelfb->varfbsize);
688	return;
689	}
690	if(flag == 0)
691	{
692	quelle = accelfb->fb;
693	ziehl = skinfb->fb + (posy * skinfb->pitch) + (posx*4);
694	zpitch = skinfb->pitch;
695	zheight = skinfb->height;
696	}
697	else
698	{
699	quelle = skinfb->fb;
700	ziehl = accelfb->fb + (posy * accelfb->pitch) + (posx*4);
701	zpitch = accelfb->pitch;
702	zheight = accelfb->height;
703	}
704	helpbuf = scale(quelle, width, height, 4, scalewidth, scaleheight, 0);
705
706	size_t helpb = 0;
707	size_t helpz = 0;
708	size_t help = 0;
709
710	while(helpz < scaleheight && helpz < (zheight - posy)) {
711	memcpy(ziehl[help], helpbuf[helpb], scalewidth*4);
712	help = help + zpitch;
713	helpb = helpb + scalewidth*4;
714	helpz = helpz + 1;
715	}
716
717	free(helpbuf);
718	if(flag == 0)
719	blit();
720
721	#endif
722
723	/*
724	STMFBIO_BLT_DATA blt_data;
725	memset(&blt_data, 0, sizeof(STMFBIO_BLT_DATA));
726
727	if(scalewidth == 0) scalewidth = width;
728	if(scaleheight == 0) scaleheight = height;
729
730	if(posx < 0) posx = 0;
731	if(posx > skinfb->width) posx = skinfb->width;
732	if(posy < 0) posy = 0;
733	if(posy > skinfb->height) posy = skinfb->height;
734	if(posx + scalewidth > skinfb->width) scalewidth = skinfb->width - posx;
735	if(posy + scaleheight > skinfb->height) scaleheight = skinfb->height - posy;
736
737	if(width <= 0 \|\| height <= 0 \|\| scalewidth <= 0 \|\| scaleheight <= 0) return;
738
739	if(flag == 1 && (scalewidth * scaleheight * 4) > accelfb->varfbsize)
740	{
741	err("accelfb to small %d -> %lu ", scalewidth * scaleheight * 4, accelfb->varfbsize);
742	return;
743	}
744
745	blt_data.operation = BLT_OP_COPY;
746
747	if(flag == 0)
748	{
749	if(status.usedirectfb == 1)
750	blt_data.srcOffset = fb->varfbsize;
751	else
752	blt_data.srcOffset = fb->varfbsize + skinfb->varfbsize;
753	}
754	else
755	{
756	if(status.usedirectfb == 1)
757	blt_data.srcOffset = 0;
758	else
759	blt_data.srcOffset = fb->varfbsize;
760	}
761
762	blt_data.srcPitch = width * 4;
763	blt_data.src_top = 0;
764	blt_data.src_left = 0;
765	blt_data.src_right = width;
766	blt_data.src_bottom = height;
767	blt_data.srcFormat = SURF_ARGB8888;
768	blt_data.srcMemBase = STMFBGP_FRAMEBUFFER;
769
770	if(flag == 0)
771	{
772	if(status.usedirectfb == 1)
773	{
774	blt_data.dstOffset = 0;
775	blt_data.dstPitch = fb->pitch;
776	}
777	else
778	{
779	blt_data.dstOffset = fb->varfbsize;
780	blt_data.dstPitch = skinfb->pitch;
781	}
782	}
783	else
784	{
785	if(status.usedirectfb == 1)
786	{
787	blt_data.dstOffset = fb->varfbsize;
788	blt_data.dstPitch = skinfb->pitch;
789	}
790	else
791	{
792	blt_data.dstOffset = fb->varfbsize + skinfb->varfbsize;
793	blt_data.dstPitch = scalewidth * 4;
794	}
795	}
796
797	blt_data.dst_left = posx;
798	blt_data.dst_top = posy;
799	blt_data.dst_right = posx + scalewidth;
800	blt_data.dst_bottom = posy + scaleheight;
801	blt_data.dstFormat = SURF_ARGB8888;
802	blt_data.dstMemBase = STMFBGP_FRAMEBUFFER;
803
804	if (ioctl(fb->fd, STMFBIO_BLT, &blt_data) < 0)
805	{
806	perr("ioctl STMFBIO_BLT");
807	}
808	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
809	{
810	perr("ioctl STMFBIO_SYNC_BLITTER");
811	}
812	*/
813	#endif
814	}
815
816	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)
817	//void blitjpg(unsigned char* buf, int posx, int posy, int width, int height, int scalewidth, int scaleheight)
818	{
819	#ifndef SIMULATE
820	#ifdef BLITHELP
821	unsigned char *helpbuf = NULL;
822	unsigned char *framebuf = NULL;
823
824	if(scalewidth != 0 \|\| scaleheight != 0) {
825	helpbuf = scale(buf, width, height, 3, scalewidth, scaleheight, 1);
826	if(helpbuf == NULL)
827	return;
828	}
829	else {
830	helpbuf = buf;
831	scalewidth = width;
832	scaleheight = height;
833	}
834	size_t helpb = 0;
835	size_t helpz = 0;
836	size_t help = 0;
837
838	framebuf = skinfb->fb;
839	framebuf = framebuf + (posy * skinfb->pitch) + (posx*4);
840
841	while(helpz < scaleheight && helpz < (skinfb->height - posy)) {
842	help = 0;
843	while(help < (scalewidth4) && help < (skinfb->pitch - (posx4))) {
844	framebuf[help+0] = helpbuf[helpb+2];
845	framebuf[help+1] = helpbuf[helpb+1];
846	framebuf[help+2] = helpbuf[helpb+0];
847	framebuf[help+3] = 0xff;
848	help = help + 4;
849	helpb = helpb + 3;
850	}
851	if(help >= (skinfb->pitch - (posx*4)))
852	helpb = (helpz+1) * (scalewidth*3);
853	framebuf = framebuf + skinfb->pitch;
854	helpz = helpz + 1;
855	}
856	free(helpbuf);
857	blit();
858	#endif
859
860	/*
861	STMFBIO_BLT_EXTERN_DATA blt_data;
862	memset(&blt_data, 0, sizeof(STMFBIO_BLT_EXTERN_DATA));
863
864	blt_data.operation = BLT_OP_COPY;
865	blt_data.ulFlags = 0;
866	blt_data.srcOffset = 0;
867	blt_data.srcPitch = width * 3;
868	blt_data.dstOffset = 0;
869	blt_data.dstPitch = skinfb->pitch;
870	blt_data.src_top = 0;
871	blt_data.src_left = 0;
872	blt_data.src_right = width;
873	blt_data.src_bottom = height;
874	blt_data.dst_left = posx;
875	blt_data.dst_top = posy;
876
877	if(scalewidth == 0) scalewidth = width;
878	if(scaleheight == 0) scaleheight = height;
879
880	blt_data.dst_right = posx + scalewidth;
881	blt_data.dst_bottom = posy + scaleheight;
882	blt_data.srcFormat = SURF_BGR888;
883	blt_data.dstFormat = SURF_ARGB8888;
884	blt_data.srcMemBase = (char *)buf;
885	blt_data.dstMemBase = (char *)skinfb->fb;
886	blt_data.srcMemSize = width * height * 3;
887	blt_data.dstMemSize = skinfb->pitch * skinfb->height;
888
889	if(ioctl(skinfb->fd, STMFBIO_BLT_EXTERN, &blt_data) < 0)
890	{
891	err("ioctl STMFBIO_BLT_EXTERN");
892	}
893	if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
894	{
895	perr("ioctl STMFBIO_SYNC_BLITTER");
896	}
897	*/
898
899	#endif
900	}
901
902	void initsignal(struct sigaction* sa)
903	{
904	sigaction(SIGILL, sa, NULL);
905	sigaction(SIGBUS, sa, NULL);
906	sigaction(SIGFPE, sa, NULL);
907	sigaction(SIGUSR1, sa, NULL);
908	sigaction(SIGSEGV, sa, NULL);
909	sigaction(SIGUSR2, sa, NULL);
910	sigaction(SIGPIPE, sa, NULL);
911	sigaction(SIGALRM, sa, NULL);
912	// sigaction(SIGSTKFLT, sa, NULL);
913	sigaction(SIGABRT, sa, NULL);
914
915	signal(SIGHUP, SIG_IGN);
916	signal(SIGINT, SIG_IGN);
917	signal(SIGTRAP, SIG_IGN);
918	signal(SIGXCPU, SIG_IGN);
919	signal(SIGXFSZ, SIG_IGN);
920	signal(SIGVTALRM, SIG_IGN);
921	signal(SIGPROF, SIG_IGN);
922	signal(SIGPOLL, SIG_IGN);
923	signal(SIGRTMAX, SIG_IGN);
924	signal(SIGPWR, SIG_IGN);
925	signal(SIGSYS, SIG_IGN);
926	}
927
928	void sighandler(int sig, struct sigcontext ctx)
929	{
930	switch(sig)
931	{
932	case SIGALRM:
933	{
934	err("got signal sigalrm but ignore it");
935	break;
936	}
937	case SIGPIPE:
938	{
939	err("got signal sigpipe but ignore it");
940	break;
941	}
942	case SIGUSR1:
943	{
944	//todo all configs
945	reloadconfig(status.configfile);
946	reloadconfig(getconfig("ownconfig", NULL));
947	break;
948	}
949	case SIGUSR2: //called if hanging mainthread detect
950	{
951	debugstack(sig, NULL, NULL);
952	break;
953	}
954	case SIGILL:
955	case SIGBUS:
956	case SIGFPE:
957	case SIGSEGV:
958	// case SIGSTKFLT:
959	{
960	/*
961	#ifdef SIMULATE
962	//intel
963	debugstack((void *)ctx.eip, NULL);
964	err("got signal %d, fault address 0x%lx from 0x%lx", sig, ctx.cr2, ctx.eip);
965	#else
966	// sh4
967	//unsigned long sc_regs[16];
968	//unsigned long sc_pc; //programm counter register
969	//unsigned long sc_pr; //procedure register
970	//unsigned long sc_sr; //status register
971	//unsigned long sc_gbr;
972	//unsigned long sc_mach;
973	//unsigned long sc_macl;
974
975	debugstack(sig, (void )ctx.sc_pr, (void )ctx.sc_pc);
976	err("got signal %d (%s), programm counter reg: 0x%lx, procedure reg: 0x%lx", sig, strsignal(sig), ctx.sc_pc, ctx.sc_pr);
977	#endif
978	*/
979	if(getconfigint("saverun", NULL) == 1 && status.longjumpbuf != NULL)
980	siglongjmp(status.longjumpbuf, 999);
981	else
982	exit(100);
983	break;
984	}
985	}
986	}
987
988	int setvmpeg(struct dvbdev* node, int value, int flag)
989	{
990	debug(4440, "in");
991	char* vmpegdev = NULL, tmpstr = NULL, buf = NULL;
992	int ret = 0;
993
994	if(node == NULL) return 1;
995	if(flag == 0) vmpegdev = getconfig("vmpegleftdev", NULL);
996	if(flag == 1) vmpegdev = getconfig("vmpegtopdev", NULL);
997	if(flag == 2) vmpegdev = getconfig("vmpegwidthdev", NULL);
998	if(flag == 3) vmpegdev = getconfig("vmpegheightdev", NULL);
999	if(flag == 99) vmpegdev = getconfig("vmpegapplydev", NULL);
1000
1001	if(vmpegdev != NULL)
1002	{
1003	buf = malloc(MINMALLOC);
1004	if(buf == NULL)
1005	{
1006	err("no mem");
1007	return 1;
1008	}
1009
1010	tmpstr = malloc(10);
1011	if(tmpstr == NULL)
1012	{
1013	err("no mem");
1014	free(buf);
1015	return 1;
1016	}
1017
1018	snprintf(buf, MINMALLOC, vmpegdev, node->devnr);
1019	snprintf(tmpstr, 10, "%x", value);
1020	debug(444, "set %s to %s", buf, tmpstr);
1021	status.tvpic = 1;
1022	ret = writesys(buf, tmpstr, 1);
1023
1024	free(tmpstr);
1025	free(buf);
1026	return ret;
1027	}
1028
1029	debug(4440, "out");
1030	return 0;
1031	}
1032
1033	//flag 0: wh = width
1034	//flag 1: wh = height
1035	int setvmpegrect(struct dvbdev* node, int left, int top, int wh, int flag)
1036	{
1037	int ret = 0;
1038
1039	if(flag == 0)
1040	{
1041	ret = setvmpeg(node, wh, 2);
1042	ret = setvmpeg(node, wh / 1.4, 3);
1043	}
1044	if(flag == 1)
1045	{
1046	ret = setvmpeg(node, wh, 3);
1047	ret = setvmpeg(node, wh * 1.3, 2);
1048	}
1049
1050	ret = setvmpeg(node, left, 0);
1051	ret = setvmpeg(node, top, 1);
1052
1053	setvmpeg(node, 0, 99);
1054
1055	return ret;
1056	}
1057
1058	int resetvmpeg(struct dvbdev* node)
1059	{
1060	int ret = 0;
1061
1062	ret = setvmpeg(node, 0, 0);
1063	ret = setvmpeg(node, 0, 1);
1064	ret = setvmpeg(node, 0, 2);
1065	ret = setvmpeg(node, 0, 3);
1066
1067	ret = setvmpeg(node, 0, 99);
1068
1069	return ret;
1070	}
1071
1072	int resettvpic()
1073	{
1074	/*
1075	if(status.tvpic == 1 && status.aktservice != NULL)
1076	{
1077	status.tvpic = 0;
1078	resetvmpeg(status.aktservice->videodev);
1079	}
1080	*/
1081	int ret = 0;
1082
1083	if(status.tvpic > 0 && status.aktservice != NULL)
1084	{
1085	status.tvpic = 0;
1086	ret = resetvmpeg(status.aktservice->videodev);
1087	}
1088
1089	return ret;
1090	}
1091
1092	int cagetslotinfo(struct dvbdev* node, ca_slot_info_t* info)
1093	{
1094	int ret = 0;
1095
1096	if(node == NULL \|\| info == NULL)
1097	{
1098	err("NULL detect");
1099	return 1;
1100	}
1101
1102	struct pollfd fds;
1103
1104	fds.fd = node->fd;
1105	fds.events = POLLOUT \| POLLPRI \| POLLIN;
1106
1107	info->flags = 0;
1108
1109	ret = TEMP_FAILURE_RETRY(poll(&fds, 1, 1000));
1110
1111	if(ret < 0)
1112	{
1113	err("poll data");
1114	return 1; //error
1115	}
1116	else if(ret == 0)
1117	return 0; //timeout
1118	else if(ret > 0)
1119	{
1120	if(fds.revents & POLLOUT)
1121	info->flags = CA_CI_MODULE_READY;
1122	if(fds.revents & POLLIN)
1123	info->flags = CA_CI_MODULE_READY;
1124	if(fds.revents & POLLPRI)
1125	info->flags = 0;
1126	}
1127
1128	return 0;
1129	}
1130
1131	void memcpy_word(char* dest, char* src, long anzw)
1132	{
1133	// Folgende Werte müssen volatile definiert sein
1134	// char* memcpy_word_src ---> pointer Quelle
1135	// char* memcpy_word_dest ---> pointer Ziehl
1136	// long memcpy_word_anzw ---> Anzahl der Wörter (4 byte) die kopiert werden sollen.
1137
1138	memcpy_word_src = src;
1139	memcpy_word_dest = dest;
1140	memcpy_word_anzw = anzw;
1141
1142	asm(
1143	" lw $8, memcpy_word_src \n"
1144	" lw $9, memcpy_word_dest \n"
1145	" lw $10, memcpy_word_anzw \n"
1146	" addi $10, $10, -1 \n"
1147	"loop1: \n"
1148	" lw $11, ($8) \n"
1149	" sw $11, ($9) \n"
1150	" addi $8, $8, 4 \n"
1151	" addi $9, $9, 4 \n"
1152	" addi $10, $10, -1 \n"
1153	" bgez $10, loop1 \n"
1154	);
1155	}
1156
1157	void memcpy_byte(char* dest, char* src, long anzb)
1158	{
1159	// Folgende Werte müssen volatile definiert sein
1160	// char* memcpy_byte_src ---> pointer Quelle
1161	// char* memcpy_byte_dest ---> pointer Ziehl
1162	// long memcpy_byte_anzb ---> Anzahl bytes die kopiert werden sollen.
1163
1164	memcpy_byte_src = src;
1165	memcpy_byte_dest = dest;
1166	memcpy_byte_anzb = anzb;
1167
1168	asm (
1169	" li $12, 4 \n"
1170	" lw $8, memcpy_byte_src \n"
1171	" lw $9, memcpy_byte_dest \n"
1172	" lw $10, memcpy_byte_anzb \n"
1173	"word: \n"
1174	" bltu $10, $12, byte \n"
1175	" lw $11, ($8) \n"
1176	" sw $11, ($9) \n"
1177	" addi $8, $8, 4 \n"
1178	" addi $9, $9, 4 \n"
1179	" addi $10, $10, -4 \n"
1180	" b word \n"
1181	"byte: \n"
1182	" beqz $10, end \n"
1183	" lb $11, ($8) \n"
1184	" sb $11, ($9) \n"
1185	" addi $8, $8, 1 \n"
1186	" addi $9, $9, 1 \n"
1187	" addi $10, $10, -1 \n"
1188	" b byte \n"
1189	"end: \n"
1190	" nop \n"
1191	);
1192	}
1193
1194
1195	void memcpy_area(unsigned char* ziehlADDR, unsigned char* startADDR, long pxAbs, long hight, long widthAbs, long FBwidthAbs)
1196	{
1197
1198	asm(
1199
1200	" lw $t3, %[ziehlADDR] \n"
1201	" lw $t4, %[startADDR] \n"
1202	" lw $t5, %[pxAbs] \n"
1203	" lw $t6, %[widthAbs] \n"
1204	" lw $t7, %[FBwidthAbs] \n"
1205	" lw $t8, %[hight] \n"
1206
1207	" move $t0, $t4 # Temp-startADDR \n"
1208	" move $t1, $t6 # Temp-widthAbs \n"
1209	" add $t2, $t5, $t6 \n"
1210	" sub $t7, $t7, $t2 # Diff withAbs und FBwidthAbs \n"
1211
1212	"p3NewLine2: \n"
1213	" beqz $t8, p3End \n"
1214	"p3NextWord: \n"
1215	" beqz $t1, p3NewLine1 \n"
1216	" lw $t9, ($t0) \n"
1217	" sw $t9, ($t3) \n"
1218	" addi $t0, 4 \n"
1219	" addi $t3, 4 \n"
1220	" addi $t1, -4 \n"
1221	" b p3NextWord \n"
1222
1223
1224	"p3NewLine1: \n"
1225	" move $t0, $t4 \n"
1226	" move $t1, $t6 \n"
1227	" add $t3, $t3, $t7 \n"
1228	" add $t3, $t3, $t5 \n"
1229	" addi $t8, -1 \n"
1230	" b p3NewLine2 \n"
1231
1232	"p3End: \n"
1233	" nop \n"
1234	::[ziehlADDR] "m" (ziehlADDR), [startADDR] "m" (startADDR), [pxAbs] "m" (pxAbs), [widthAbs] "m" (widthAbs), [FBwidthAbs] "m" (FBwidthAbs), [hight] "m" (hight)
1235	);
1236
1237	return;
1238	}
1239
1240	int setfbosddev(char* dev, int value)
1241	{
1242	char* tmpstr = NULL;
1243	int ret = 0;
1244
1245	tmpstr = malloc(10);
1246	if(tmpstr == NULL)
1247	{
1248	err("no mem");
1249	return 1;
1250	}
1251
1252	sprintf(tmpstr, "%x", value);
1253	debug(101, "set %s to %s", dev, tmpstr);
1254
1255	if(dev != NULL)
1256	{
1257	ret = writesys(dev, tmpstr, 1);
1258	return ret;
1259	}
1260
1261	return 0;
1262	}
1263
1264	char* getfbosddev(char* dev)
1265	{
1266	char *value = NULL;
1267
1268	if(dev == NULL)
1269	{
1270	err("NULL detect");
1271	return NULL;
1272	}
1273
1274	value = readsys(dev, 1);
1275	if(value == NULL)
1276	{
1277	err("NULL detect");
1278	return NULL;
1279	}
1280
1281	debug(101, "get %s to %s", dev, value);
1282
1283	return value;
1284	}
1285
1286
1287	void setfbosd()
1288	{
1289	debug(101, "################## set osd offset ####################");
1290	debug(101, "status.leftoffset: %d", status.leftoffset);
1291	debug(101, "status.rightoffset: %d", status.rightoffset);
1292	debug(101, "status.topoffset: %d", status.topoffset);
1293	debug(101, "status.bottomoffset: %d", status.bottomoffset);
1294
1295	char* fbleftdev = "/proc/stb/fb/dst_left";
1296	char* fbwidthdev = "/proc/stb/fb/dst_width";
1297	char* fbtopdev = "/proc/stb/fb/dst_top";
1298	char* fbheightdev = "/proc/stb/fb/dst_height";
1299
1300	int fbleft = strtol(getfbosddev(fbleftdev) , NULL, 16);
1301	int fbwidth = strtol(getfbosddev(fbwidthdev) , NULL, 16);
1302	int fbtop = strtol(getfbosddev(fbtopdev) , NULL, 16);
1303	int fbheight = strtol(getfbosddev(fbheightdev) , NULL, 16);
1304	debug(101, "Setting OSD position: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1305
1306	fbleft = status.leftoffset;
1307	fbwidth = 720 - status.leftoffset - status.rightoffset;
1308	fbtop = status.topoffset;
1309	fbheight = 576 - status.topoffset - status.bottomoffset;
1310	debug(101, "Setting OSD position changed: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1311	debug(10, "Setting OSD position changed: %d %d %d %d", fbleft ,fbwidth ,fbtop ,fbheight);
1312
1313	setfbosddev(fbleftdev, fbleft);
1314	setfbosddev(fbwidthdev, fbwidth);
1315	setfbosddev(fbtopdev, fbtop);
1316	setfbosddev(fbheightdev, fbheight);
1317	debug(101, "######################################################");
1318	}
1319
1320	#endif

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

Download in other formats: