source: titan/titan/mipselport.h @ 37100

Last change on this file since 37100 was 37100, checked in by gost, 8 years ago

[titan] activate animated menus for all mipsel

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