source: titan/titan/fb.h @ 35769

Last change on this file since 35769 was 26549, checked in by obi, 10 years ago

fix build

File size: 10.9 KB
Line 
1#ifndef FB_H
2#define FB_H
3
4struct fb* getfb(char *name)
5{
6        struct fb *node = fb;
7
8        while(node != NULL)
9        {
10                if(ostrstr(node->name, name) != NULL)
11                        return node;
12
13                node = node->next;
14        }
15        debug(444, "framebuffer not found (%s)", name);
16        return NULL;
17}
18
19long getfbsize(int dev)
20{
21        struct fb* node = fb;
22        unsigned long fbmemcount = 0;
23        struct fb_fix_screeninfo fix_screeninfo;
24
25        if(fb == NULL)
26        {
27                err("NULL dedect");
28                return 0;
29        }
30
31#ifndef NOFB
32        if(ioctl(fb->fd, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
33        {
34                perr("ioctl FBIOGET_FSCREENINFO failed");
35                return 0;
36        }
37#else
38        fix_screeninfo.smem_len = 16*1024*1024;
39#endif
40
41        while(node != NULL)
42        {
43                if(node->dev == dev)
44                        fbmemcount = fbmemcount + node->varfbsize;
45                node = node->next;
46        }
47       
48        return fix_screeninfo.smem_len - fbmemcount;
49}
50
51struct fb* addfb(char *fbname, int dev, int width, int height, int colbytes, int fd, unsigned char* mmapfb, unsigned long fixfbsize)
52{
53        struct fb *newnode = NULL, *node = fb;
54        char *name = NULL;
55        long ret = 0;
56
57        name = ostrcat(fbname, NULL, 0, 0);
58        if(name == NULL)
59        {
60                err("no memory");
61                return NULL;
62        }
63
64        newnode = (struct fb*)malloc(sizeof(struct fb));       
65        if(newnode == NULL)
66        {
67                err("no memory");
68                free(name);
69                return NULL;
70        }
71
72        memset(newnode, 0, sizeof(struct fb));
73        newnode->name = name;
74        newnode->dev = dev;
75        newnode->width = width;
76        newnode->height = height;
77        newnode->colbytes = colbytes;
78        newnode->pitch = newnode->width * newnode->colbytes;
79        newnode->fb = mmapfb;
80        newnode->fblong = (unsigned long*)newnode->fb;
81        newnode->fd = fd;
82        newnode->fixfbsize = fixfbsize;
83       
84        if(ostrcmp(name, FB) == 0)
85                setfbvarsize(newnode);
86        else if(ostrcmp(name, FB1) == 0)
87                newnode->varfbsize = 720 * 576 * newnode->colbytes;
88        else
89                newnode->varfbsize = width * height * newnode->colbytes;
90       
91        if(node != NULL)
92        {
93                while(node->next != NULL)
94                        node = node->next;
95                node->next = newnode;
96        }
97        else
98                fb = newnode;
99               
100        /*eigener Buffer zB fuer LCD*/
101        if(dev == 999)
102                return newnode;
103
104        ret = getfbsize(dev);
105        if(ret < 0)
106        {
107                err("framebuffermem (%s) to small, needed = %ld", name, ret * -1);
108                free(name);
109                free(newnode);
110                if(newnode == fb) fb = NULL;
111                return NULL;
112        }
113
114        debug(444, "fbname=%s, fbwidth=%d, fbheight=%d, fbcol=%d, fbsize=%ld", newnode->name, newnode->width, newnode->height, newnode->colbytes, newnode->varfbsize);
115        return newnode;
116}
117
118void fb2png_thread()
119{
120        while (writeFBfile.buf1 != NULL || writeFBfile.buf2 != NULL) {
121                if(writeFBfile.buf1 != NULL) {
122                        writeFBfile.ActBuf = writeFBfile.buf1;
123                        fb2png(writeFBfile.buf1, 320, 240, "/tmp/titanlcd.png");
124                        free(writeFBfile.buf1); writeFBfile.buf1 = NULL;
125                        if(writeFBfile.buf2 != NULL)
126                                usleep(500000);
127                }
128                if(writeFBfile.buf2 != NULL) {
129                        writeFBfile.ActBuf = writeFBfile.buf2;
130                        fb2png(writeFBfile.buf2, 320, 240, "/tmp/titanlcd.png");
131                        free(writeFBfile.buf2); writeFBfile.buf2 = NULL;
132                        if(writeFBfile.buf1 != NULL)
133                                usleep(500000);
134                }
135        }
136        writeFBfile.ActBuf = NULL;
137}
138
139void delfb(char *name)
140{
141        struct fb *node = fb, *prev = fb;
142
143        while(node != NULL)
144        {
145                if(ostrcmp(node->name, name) == 0)
146                {
147                        if(node == fb)
148                                fb = node->next;
149                        else
150                                prev->next = node->next;
151
152                        free(node->name);
153                        node->name = NULL;
154
155                        free(node);
156                        node = NULL;
157                        break;
158                }
159
160                prev = node;
161                node = node->next;
162        }
163}
164
165void freefb()
166{
167        struct fb *node = fb, *prev = fb;
168
169        while(node != NULL)
170        {
171                prev = node;
172                node = node->next;
173                if(prev != NULL)
174                        delfb(prev->name);
175        }
176}
177
178struct fb* openfb(char *fbdev, int devnr)
179{
180        int fd = -1;
181        unsigned char *mmapfb = NULL;
182        struct fb_var_screeninfo var_screeninfo;
183        struct fb_fix_screeninfo fix_screeninfo;
184        struct fb* node = NULL;
185
186        if(fbdev == NULL)
187        {
188                err("failed to find fbdev in config file");
189                return NULL;
190        }
191
192#ifndef NOFB
193        fd = open(fbdev, O_RDWR);
194
195// blinking work start
196#ifdef MIPSEL
197        if (fd < 0)
198        {
199                        perror(fbdev);
200                        goto nolfb;
201                }
202#endif
203// blinking work end
204               
205        if(fd == -1)
206        {
207                perr("failed to open %s", fbdev);
208                return NULL;
209        }
210        closeonexec(fd);
211       
212        if(ioctl(fd, FBIOGET_VSCREENINFO, &var_screeninfo) == -1)
213        {
214                perr("ioctl FBIOGET_VSCREENINFO failed");
215                close(fd);
216                return NULL;
217        }
218
219        if(ioctl(fd, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
220        {
221                perr("ioctl FBIOGET_FSCREENINFO failed");
222                close(fd);
223                return NULL;
224        }
225
226        if(!(mmapfb = (unsigned char*)mmap(0, fix_screeninfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)))
227        {
228                perr("mmap framebuffer");
229                close(fd);
230                return NULL;
231        }
232
233        debug(444, "%dk video mem", fix_screeninfo.smem_len/1024);
234
235#ifdef MIPSEL
236        lfb = (unsigned char*)mmap(0, fix_screeninfo.smem_len, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
237        if (!lfb)
238        {
239                perror("mmap");
240                goto nolfb;
241        }
242
243        if (var_screeninfo.bits_per_pixel != 32)
244        {
245                debug(444, "Only 32 bit per pixel supported. Framebuffer currently use %d", var_screeninfo.bits_per_pixel);
246                closefb();
247                return 0;
248        }
249#endif
250
251
252        if(devnr == 0)
253                node = addfb(FB, devnr, var_screeninfo.xres, var_screeninfo.yres, var_screeninfo.bits_per_pixel / 8, fd, mmapfb, fix_screeninfo.smem_len);
254        if(devnr == 1)
255                node = addfb(FB1, devnr, var_screeninfo.xres, var_screeninfo.yres, var_screeninfo.bits_per_pixel / 8, fd, mmapfb, fix_screeninfo.smem_len);
256
257#else
258        mmapfb = malloc(16 * 1024 * 1024);
259        if(devnr == 0)
260                node = addfb(FB, devnr, getconfigint("skinfbwidth", NULL), getconfigint("skinfbheight", NULL), 4, -1, mmapfb, 16*1024*1024);
261        if(devnr == 1)
262                node = addfb(FB1, devnr, getconfigint("skinfbwidth", NULL), getconfigint("skinfbheight", NULL), 4, -1, mmapfb, 16*1024*1024);
263
264#endif
265
266        return node;
267
268#ifdef MIPSEL
269nolfb:
270        if (fd >= 0)
271        {
272                close(fd);
273                fd = -1;
274        }
275
276        debug(444, "framebuffer not available.");
277#endif
278        return 0;
279// blinking work end
280}
281
282void closefb()
283{
284
285#ifdef MIPSEL
286        if(lfb)
287        {
288                debug(444, "ms_sync");
289                msync(lfb, fix_screeninfo.smem_len, MS_SYNC);
290                munmap(lfb, fix_screeninfo.smem_len);
291        }
292        if(fb->fd >= 0)
293        {
294                debug(444, "close");
295                disablemanualblit();
296                close(fb->fd);
297                fb->fd = -1;
298        }
299#endif
300
301        if(fb != NULL)
302        {
303                if(fb->fb != NULL)
304                        munmap(fb->fb, fb->fixfbsize);
305                if(fb->fd != -1)
306                        close(fb->fd);
307#ifdef NOFB
308                free(fb->fb);
309#endif
310        }
311}
312
313void clearfball()
314{
315        if(fb != NULL && fb->fb != NULL)
316                memset(fb->fb, 0, fb->fixfbsize);
317}
318
319void clearfb(struct fb *node)
320{
321        if(node != NULL)
322                memset(node->fb, 0, node->varfbsize);
323}
324
325void blitfb(int flag)
326{
327        blitfb2(skinfb, flag);
328}
329
330void blitfb1()
331{
332        blitfb2(skinfb, 0);
333}
334
335//flag 0: del skinfb
336//flag 1: don't del skinfb
337void changefbresolution(char *value, int flag)
338{
339        debug(444, "fb->colbytes: %d", fb->colbytes);
340#ifdef MIPSEL
341        return;
342#endif
343
344        if(ostrcmp("pal", value) == 0)
345        {
346                fb->width = 720;
347                fb->height = 576;
348                fb->pitch = fb->width * fb->colbytes;
349        }
350        else if(ostrncmp("576", value, 3) == 0)
351        {
352                fb->width = 720;
353                fb->height = 576;
354                fb->pitch = fb->width * fb->colbytes;
355        }
356        else if(ostrncmp("720", value, 3) == 0)
357        {
358                fb->width = 1280;
359                fb->height = 720;
360                fb->pitch = fb->width * fb->colbytes;
361        }
362        else if(ostrncmp("1080", value, 4) == 0)
363        {
364                fb->width = 1920;
365                fb->height = 1080;
366                fb->pitch = fb->width * fb->colbytes;
367        }
368        if(skinfb == fb)
369        {
370                skin->width = skinfb->width;
371                skin->height = skinfb->height;
372                skin->iwidth = skinfb->width;
373                skin->iheight = skinfb->height;
374                skin->rwidth = skinfb->width;
375                skin->rheight = skinfb->height;
376        }
377        clearfb(fb);
378        if(flag == 0) clearfb(skinfb);
379}
380
381static void write_PNG(unsigned char *outbuffer, char *filename,
382                                int width, int height, int interlace)
383{
384        int i;
385        int bit_depth=0, color_type;
386        png_bytep row_pointers[height];
387        png_structp png_ptr;
388        png_infop info_ptr;
389        FILE *outfile = fopen(filename, "wb");
390
391        for (i=0; i<height; i++)
392                row_pointers[i] = outbuffer + i * 4 * width;
393               
394        if (!outfile)
395        {
396                fprintf (stderr, "Error: Couldn't fopen %s.\n", filename);
397                exit(EXIT_FAILURE);
398        }
399   
400        png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
401        (png_voidp) NULL, (png_error_ptr) NULL, (png_error_ptr) NULL);
402   
403        if (!png_ptr)
404                err("Error: Couldn't create PNG write struct.");
405   
406        info_ptr = png_create_info_struct(png_ptr);
407        if (!info_ptr)
408        {
409                png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
410                err("Error: Couldn't create PNG info struct.");
411        }
412   
413        png_init_io(png_ptr, outfile);
414   
415        png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
416   
417        bit_depth = 8;
418        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
419        //color_type = PNG_COLOR_TYPE_RGB;
420        png_set_invert_alpha(png_ptr);
421        png_set_bgr(png_ptr);
422
423        png_set_IHDR(png_ptr, info_ptr, width, height,
424        bit_depth, color_type, interlace,
425        PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
426   
427        png_write_info(png_ptr, info_ptr);
428   
429        printf ("Now writing PNG file\n");
430   
431        png_write_image(png_ptr, row_pointers);
432   
433        png_write_end(png_ptr, info_ptr);
434        /* puh, done, now freeing memory... */
435        png_destroy_write_struct(&png_ptr, &info_ptr);
436   
437        if (outfile != NULL)
438                (void) fclose(outfile);
439}
440
441static void convert_and_write(unsigned char *inbuffer, char *filename,
442                                int width, int height, int bits, int interlace)
443{
444        size_t bufsize = (size_t) width * height * 4;
445
446        unsigned char *outbuffer = malloc(bufsize);
447
448        if (outbuffer == NULL)
449                err("Not enough memory");
450       
451        memset(outbuffer, 0, bufsize);
452        write_PNG(inbuffer, filename, width, height, interlace);
453        (void) free(outbuffer);
454}
455
456int fb2png(unsigned char *buf_p, int width, int height, char *outfile)
457{
458        int interlace = PNG_INTERLACE_ADAM7;
459        int bitdepth = 32;
460               
461        size_t help = 0;
462        while(help <= (width * height * 4))
463        {
464                buf_p[help+3] = 0x00;
465                help = help + 4;
466        }
467               
468        convert_and_write(buf_p, outfile, width, height, bitdepth, interlace);
469
470        return 0;
471}
472
473void pngforlcd(unsigned char *fbuffer, int width, int height)
474{
475        fb2png(fbuffer, width, height, "/tmp/titanlcd.png");
476}
477
478void write_FB_to_JPEG_file(unsigned char *inbuffer, int image_width, int image_height, char * filename, int quality)
479{               
480        size_t helpb = 0;
481        size_t help = 0;
482        unsigned char *helpbuffer = malloc(image_width*image_height*3);
483       
484        //delete alpha byte
485        while(help <= (image_width*image_height*4))
486        {
487                helpbuffer[helpb+0] = inbuffer[help+2];
488                helpbuffer[helpb+1] = inbuffer[help+1];
489                helpbuffer[helpb+2] = inbuffer[help+0];
490                help = help + 4;
491                helpb = helpb + 3;
492        }
493       
494        JSAMPLE *image_buffer = helpbuffer;
495        struct jpeg_compress_struct cinfo;
496        struct jpeg_error_mgr jerr;
497        FILE * outfile;
498       
499        JSAMPROW row_pointer[1];
500        int row_stride;
501       
502        cinfo.err = jpeg_std_error(&jerr);
503        jpeg_create_compress(&cinfo);
504        if ((outfile = fopen(filename, "wb")) == NULL) {
505                fprintf(stderr, "can't open %s\n", filename);
506                exit(1);
507        }
508        jpeg_stdio_dest(&cinfo, outfile);
509        cinfo.image_width = image_width;        /* image width and height, in pixels */
510        cinfo.image_height = image_height;
511        cinfo.input_components = 3;             /* # of color components per pixel */
512        cinfo.in_color_space = JCS_RGB;
513
514        jpeg_set_defaults(&cinfo);
515        jpeg_set_quality(&cinfo, quality, TRUE);
516
517        jpeg_start_compress(&cinfo, TRUE);
518        row_stride = image_width * 3;
519
520        while (cinfo.next_scanline < cinfo.image_height) {
521                row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
522                (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
523        }
524
525        jpeg_finish_compress(&cinfo);
526        fclose(outfile);
527        jpeg_destroy_compress(&cinfo);
528   
529        free(helpbuffer);
530}
531
532#endif
Note: See TracBrowser for help on using the repository browser.