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