source: titan/titan/mipselport.h @ 37125

Last change on this file since 37125 was 37125, checked in by gost, 7 years ago

[titan] atemio5200 deactivate animation

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