Mercurial > mplayer.hg
annotate libvo/vo_fbdev.c @ 519:5e8d5422854d
changed query_format return; lots of fixes/changes
author | szabii |
---|---|
date | Thu, 19 Apr 2001 01:18:05 +0000 |
parents | 4aa16f9ff929 |
children | 4df60675000a |
rev | line source |
---|---|
305 | 1 /* |
2 * Video driver for Framebuffer device | |
3 * by Szabolcs Berecz <szabi@inf.elte.hu> | |
359 | 4 * (C) 2001 |
305 | 5 * |
6 * Some idea and code borrowed from Chris Lawrence's ppmtofb-0.27 | |
7 */ | |
8 | |
393 | 9 #define FBDEV "fbdev: " |
10 | |
225 | 11 #include <stdio.h> |
12 #include <stdlib.h> | |
13 #include <string.h> | |
14 #include <fcntl.h> | |
15 #include <unistd.h> | |
16 #include <errno.h> | |
359 | 17 #include <ctype.h> |
18 #include <assert.h> | |
225 | 19 |
20 #include <sys/mman.h> | |
21 #include <sys/ioctl.h> | |
22 #include <linux/fb.h> | |
23 #include <linux/vt.h> | |
24 | |
25 #include "config.h" | |
26 #include "video_out.h" | |
27 #include "video_out_internal.h" | |
28 | |
29 #include "yuv2rgb.h" | |
311 | 30 extern void rgb15to16_mmx(char *s0, char *d0, int count); |
225 | 31 |
354 | 32 #include "fastmemcpy.h" |
350 | 33 |
225 | 34 LIBVO_EXTERN(fbdev) |
35 | |
36 static vo_info_t vo_info = { | |
37 "Framebuffer Device", | |
38 "fbdev", | |
39 "Szabolcs Berecz <szabi@inf.elte.hu>", | |
40 "" | |
41 }; | |
42 | |
379 | 43 extern int verbose; |
44 | |
359 | 45 /****************************** |
393 | 46 * fb.modes support * |
359 | 47 ******************************/ |
48 | |
49 /* | |
50 * read the fb.modes manual page! | |
51 */ | |
52 | |
53 typedef struct { | |
54 char *name; | |
55 uint32_t xres, yres, vxres, vyres, depth; | |
56 uint32_t pixclock, left, right, upper, lower, hslen, vslen; | |
57 uint32_t sync; | |
58 uint32_t vmode; | |
59 } fb_mode_t; | |
60 | |
61 #define PRINT_LINENUM printf(" at line %d\n", line_num) | |
62 | |
63 #define MAX_NR_TOKEN 16 | |
64 | |
65 #define MAX_LINE_LEN 1000 | |
66 | |
67 #define RET_EOF -1 | |
68 #define RET_EOL -2 | |
69 | |
70 static int validate_mode(fb_mode_t *m) | |
71 { | |
72 if (!m->xres) { | |
73 printf("needs geometry "); | |
74 return 0; | |
75 } | |
76 if (!m->pixclock) { | |
77 printf("needs timings "); | |
78 return 0; | |
79 } | |
80 return 1; | |
81 } | |
82 | |
83 static FILE *fp; | |
84 static int line_num = 0; | |
85 static char *line; | |
86 static char *token[MAX_NR_TOKEN]; | |
87 | |
88 static int get_token(int num) | |
89 { | |
90 static int read_nextline = 1; | |
91 static int line_pos; | |
92 int i; | |
93 char c; | |
94 | |
95 if (num >= MAX_NR_TOKEN) { | |
96 printf("get_token(): max >= MAX_NR_TOKEN!"); | |
97 goto out_eof; | |
98 } | |
99 | |
100 if (read_nextline) { | |
101 if (!fgets(line, MAX_LINE_LEN, fp)) | |
102 goto out_eof; | |
103 line_pos = 0; | |
104 ++line_num; | |
105 read_nextline = 0; | |
106 } | |
107 for (i = 0; i < num; i++) { | |
108 while (isspace(line[line_pos])) | |
109 ++line_pos; | |
110 if (line[line_pos] == '\0' || line[line_pos] == '#') { | |
111 read_nextline = 1; | |
112 if (i == num) | |
113 goto out_ok; | |
114 goto out_eol; | |
115 } | |
116 token[i] = line + line_pos; | |
117 c = line[line_pos]; | |
118 if (c == '"' || c == '\'') { | |
119 token[i]++; | |
120 while (line[++line_pos] != c && line[line_pos]) | |
121 /* NOTHING */; | |
122 } else { | |
123 for (/* NOTHING */; !isspace(line[line_pos]) && | |
124 line[line_pos]; line_pos++) | |
125 /* NOTHING */; | |
126 } | |
127 if (!line[line_pos]) { | |
128 read_nextline = 1; | |
129 if (i == num - 1) | |
130 goto out_ok; | |
131 goto out_eol; | |
132 } | |
133 line[line_pos] = '\0'; | |
134 line_pos++; | |
135 } | |
136 out_ok: | |
137 return i; | |
138 out_eof: | |
139 return RET_EOF; | |
140 out_eol: | |
141 return RET_EOL; | |
142 } | |
143 | |
144 static fb_mode_t *fb_modes = NULL; | |
145 static int nr_modes = 0; | |
146 | |
147 static int parse_fbmode_cfg(char *cfgfile) | |
148 { | |
149 fb_mode_t *mode = NULL; | |
150 char *endptr; // strtoul()... | |
151 int tmp, i; | |
152 | |
153 #ifdef DEBUG | |
154 assert(cfgfile != NULL); | |
155 #endif | |
156 | |
157 printf("Reading %s: ", cfgfile); | |
158 | |
159 if ((fp = fopen(cfgfile, "r")) == NULL) { | |
160 printf("can't open '%s': %s\n", cfgfile, strerror(errno)); | |
161 return -1; | |
162 } | |
163 | |
164 if ((line = (char *) malloc(MAX_LINE_LEN + 1)) == NULL) { | |
165 printf("can't get memory for 'line': %s\n", strerror(errno)); | |
166 return -2; | |
167 } | |
168 | |
169 /* | |
170 * check if the cfgfile starts with 'mode' | |
171 */ | |
172 while ((tmp = get_token(1)) == RET_EOL) | |
173 /* NOTHING */; | |
174 if (tmp == RET_EOF) | |
175 goto out; | |
176 if (!strcmp(token[0], "mode")) | |
177 goto loop_enter; | |
178 goto err_out_parse_error; | |
179 | |
180 while ((tmp = get_token(1)) != RET_EOF) { | |
181 if (tmp == RET_EOL) | |
182 continue; | |
183 if (!strcmp(token[0], "mode")) { | |
184 if (!validate_mode(mode)) | |
185 goto err_out_not_valid; | |
186 loop_enter: | |
187 if (!(fb_modes = (fb_mode_t *) realloc(fb_modes, | |
188 sizeof(fb_mode_t) * (nr_modes + 1)))) { | |
189 printf("can't realloc 'fb_modes': %s\n", strerror(errno)); | |
190 goto err_out; | |
191 } | |
192 mode=fb_modes + nr_modes; | |
193 ++nr_modes; | |
194 memset(mode,0,sizeof(fb_mode_t)); | |
225 | 195 |
359 | 196 if (get_token(1) < 0) |
197 goto err_out_parse_error; | |
198 for (i = 0; i < nr_modes - 1; i++) { | |
199 if (!strcmp(token[0], fb_modes[i].name)) { | |
200 printf("mode name '%s' isn't unique", token[0]); | |
201 goto err_out_print_linenum; | |
202 } | |
203 } | |
204 if (!(mode->name = strdup(token[0]))) { | |
205 printf("can't strdup -> 'name': %s\n", strerror(errno)); | |
206 goto err_out; | |
207 } | |
208 } else if (!strcmp(token[0], "geometry")) { | |
209 if (get_token(5) < 0) | |
210 goto err_out_parse_error; | |
211 mode->xres = strtoul(token[0], &endptr, 0); | |
212 if (*endptr) | |
213 goto err_out_parse_error; | |
214 mode->yres = strtoul(token[1], &endptr, 0); | |
215 if (*endptr) | |
216 goto err_out_parse_error; | |
217 mode->vxres = strtoul(token[2], &endptr, 0); | |
218 if (*endptr) | |
219 goto err_out_parse_error; | |
220 mode->vyres = strtoul(token[3], &endptr, 0); | |
221 if (*endptr) | |
222 goto err_out_parse_error; | |
223 mode->depth = strtoul(token[4], &endptr, 0); | |
224 if (*endptr) | |
225 goto err_out_parse_error; | |
226 } else if (!strcmp(token[0], "timings")) { | |
227 if (get_token(7) < 0) | |
228 goto err_out_parse_error; | |
229 mode->pixclock = strtoul(token[0], &endptr, 0); | |
230 if (*endptr) | |
231 goto err_out_parse_error; | |
232 mode->left = strtoul(token[1], &endptr, 0); | |
233 if (*endptr) | |
234 goto err_out_parse_error; | |
235 mode->right = strtoul(token[2], &endptr, 0); | |
236 if (*endptr) | |
237 goto err_out_parse_error; | |
238 mode->upper = strtoul(token[3], &endptr, 0); | |
239 if (*endptr) | |
240 goto err_out_parse_error; | |
241 mode->lower = strtoul(token[4], &endptr, 0); | |
242 if (*endptr) | |
243 goto err_out_parse_error; | |
244 mode->hslen = strtoul(token[5], &endptr, 0); | |
245 if (*endptr) | |
246 goto err_out_parse_error; | |
247 mode->vslen = strtoul(token[6], &endptr, 0); | |
248 if (*endptr) | |
249 goto err_out_parse_error; | |
250 } else if (!strcmp(token[0], "endmode")) { | |
251 /* NOTHING for now*/ | |
383 | 252 } else if (!strcmp(token[0], "accel")) { |
253 if (get_token(1) < 0) | |
254 goto err_out_parse_error; | |
393 | 255 /* |
256 * it's only used for text acceleration | |
257 * so we just ignore it. | |
258 */ | |
359 | 259 } else if (!strcmp(token[0], "hsync")) { |
260 if (get_token(1) < 0) | |
261 goto err_out_parse_error; | |
262 if (!strcmp(token[0], "low")) | |
263 mode->sync &= ~FB_SYNC_HOR_HIGH_ACT; | |
264 else if(!strcmp(token[0], "high")) | |
265 mode->sync |= FB_SYNC_HOR_HIGH_ACT; | |
266 else | |
267 goto err_out_parse_error; | |
268 } else if (!strcmp(token[0], "vsync")) { | |
269 if (get_token(1) < 0) | |
270 goto err_out_parse_error; | |
271 if (!strcmp(token[0], "low")) | |
272 mode->sync &= ~FB_SYNC_VERT_HIGH_ACT; | |
273 else if(!strcmp(token[0], "high")) | |
274 mode->sync |= FB_SYNC_VERT_HIGH_ACT; | |
275 else | |
276 goto err_out_parse_error; | |
277 } else if (!strcmp(token[0], "csync")) { | |
278 if (get_token(1) < 0) | |
279 goto err_out_parse_error; | |
280 if (!strcmp(token[0], "low")) | |
281 mode->sync &= ~FB_SYNC_COMP_HIGH_ACT; | |
282 else if(!strcmp(token[0], "high")) | |
283 mode->sync |= FB_SYNC_COMP_HIGH_ACT; | |
284 else | |
285 goto err_out_parse_error; | |
286 } else if (!strcmp(token[0], "extsync")) { | |
287 if (get_token(1) < 0) | |
288 goto err_out_parse_error; | |
289 if (!strcmp(token[0], "false")) | |
290 mode->sync &= ~FB_SYNC_EXT; | |
291 else if(!strcmp(token[0], "true")) | |
292 mode->sync |= FB_SYNC_EXT; | |
293 else | |
294 goto err_out_parse_error; | |
295 } else if (!strcmp(token[0], "laced")) { | |
296 if (get_token(1) < 0) | |
297 goto err_out_parse_error; | |
298 if (!strcmp(token[0], "false")) | |
299 mode->vmode = FB_VMODE_NONINTERLACED; | |
300 else if (!strcmp(token[0], "true")) | |
301 mode->vmode = FB_VMODE_INTERLACED; | |
302 else | |
303 goto err_out_parse_error; | |
479 | 304 } else if (!strcmp(token[0], "double")) { |
359 | 305 if (get_token(1) < 0) |
306 goto err_out_parse_error; | |
307 if (!strcmp(token[0], "false")) | |
308 ; | |
309 else if (!strcmp(token[0], "true")) | |
310 mode->vmode = FB_VMODE_DOUBLE; | |
311 else | |
312 goto err_out_parse_error; | |
313 } else | |
314 goto err_out_parse_error; | |
315 } | |
316 if (!validate_mode(mode)) | |
317 goto err_out_not_valid; | |
318 out: | |
319 printf("%d modes\n", nr_modes); | |
320 free(line); | |
321 fclose(fp); | |
322 return nr_modes; | |
323 err_out_parse_error: | |
324 printf("parse error"); | |
325 err_out_print_linenum: | |
326 PRINT_LINENUM; | |
327 err_out: | |
393 | 328 if (fb_modes) { |
359 | 329 free(fb_modes); |
393 | 330 fb_modes = NULL; |
331 } | |
332 nr_modes = 0; | |
359 | 333 free(line); |
334 free(fp); | |
335 return -2; | |
336 err_out_not_valid: | |
337 printf("mode is not definied correctly"); | |
338 goto err_out_print_linenum; | |
339 } | |
340 | |
341 static fb_mode_t *find_mode_by_name(char *name) | |
342 { | |
343 int i; | |
344 | |
345 for (i = 0; i < nr_modes; i++) { | |
346 if (!strcmp(name, fb_modes[i].name)) | |
347 return fb_modes + i; | |
348 } | |
349 return NULL; | |
350 } | |
351 | |
393 | 352 static float dcf(fb_mode_t *m) //driving clock frequency |
353 { | |
519 | 354 return 1e12f / m->pixclock; |
393 | 355 } |
356 | |
357 static float hsf(fb_mode_t *m) //horizontal scan frequency | |
358 { | |
359 int htotal = m->left + m->xres + m->right + m->hslen; | |
360 return dcf(m) / htotal; | |
361 } | |
362 | |
363 static float vsf(fb_mode_t *m) //vertical scan frequency | |
364 { | |
365 int vtotal = m->upper + m->yres + m->lower + m->vslen; | |
366 return hsf(m) / vtotal; | |
367 } | |
368 | |
369 typedef struct { | |
370 float min; | |
371 float max; | |
418 | 372 } range_t; |
393 | 373 |
418 | 374 static int in_range(range_t *r, float f) |
393 | 375 { |
418 | 376 for (/* NOTHING */; (r->min != -1 && r->max != -1); r++) { |
393 | 377 if (f >= r->min && f <= r->max) |
378 return 1; | |
379 } | |
380 return 0; | |
381 } | |
382 | |
418 | 383 static fb_mode_t *find_best_mode(int xres, int yres, range_t *hfreq, |
384 range_t *vfreq, range_t *dotclock) | |
393 | 385 { |
386 int i; | |
387 fb_mode_t *best = fb_modes; | |
519 | 388 fb_mode_t *curr; |
389 | |
390 /* find first working mode */ | |
391 for (i = nr_modes - 1; i; i--, best++) { | |
392 if (in_range(hfreq, hsf(best)) && in_range(vfreq, vsf(best)) && | |
393 in_range(dotclock, dcf(best))) | |
394 break; | |
395 if (verbose > 1) | |
396 printf(FBDEV "can't set %dx%d\n", best->xres, best->yres); | |
397 } | |
398 | |
399 if (!i) | |
400 return NULL; | |
401 if (i == 1) | |
402 return best; | |
393 | 403 |
519 | 404 for (curr = best + 1; i; i--, curr++) { |
405 if (!in_range(hfreq, hsf(curr))) | |
406 continue; | |
407 if (!in_range(vfreq, vsf(curr))) | |
408 continue; | |
409 if (!in_range(dotclock, dcf(curr))) | |
410 continue; | |
411 if (verbose > 1) | |
412 printf(FBDEV "%dx%d ", curr->xres, curr->yres); | |
413 if ((best->xres < xres || best->yres < yres) && | |
414 (curr->xres > best->xres || | |
415 curr->yres > best->yres)) { | |
416 if (verbose > 1) | |
417 printf("better than %dx%d\n", best->xres, | |
418 best->yres); | |
419 best = curr; | |
420 } else if (curr->xres >= xres && curr->yres >= yres) { | |
393 | 421 if (curr->xres < best->xres && curr->yres < best->yres) { |
519 | 422 if (verbose > 1) |
423 printf("smaller than %dx%d\n", | |
424 best->xres, best->yres); | |
393 | 425 best = curr; |
519 | 426 } else if (curr->xres == best->xres && |
427 curr->yres == best->yres && | |
428 (vsf(curr) > vsf(best))) { | |
429 if (verbose > 1) | |
430 printf("faster screen refresh\n"); | |
431 best = curr; | |
432 } else if (verbose > 1) | |
433 printf("\n"); | |
434 } else if (verbose > 1) | |
435 printf("is too small\n"); | |
393 | 436 } |
437 return best; | |
438 } | |
439 | |
418 | 440 static void set_bpp(struct fb_var_screeninfo *p, int bpp) |
441 { | |
476 | 442 /* p->bits_per_pixel = (bpp == 15) ? 16 : bpp; */ |
443 p->bits_per_pixel = (bpp + 1) & ~1; | |
418 | 444 p->red.msb_right = p->green.msb_right = p->blue.msb_right = 0; |
445 switch (bpp) { | |
446 case 32: | |
447 case 24: | |
448 p->red.offset = 16; | |
449 p->red.length = 8; | |
450 p->green.offset = 8; | |
451 p->green.length = 8; | |
452 p->blue.offset = 0; | |
453 p->blue.length = 8; | |
454 break; | |
455 case 16: | |
456 p->red.offset = 11; | |
457 p->red.length = 5; | |
458 p->green.offset = 5; | |
459 p->green.length = 6; | |
460 p->blue.offset = 0; | |
461 p->blue.length = 5; | |
462 break; | |
463 case 15: | |
464 p->red.offset = 10; | |
465 p->red.length = 5; | |
466 p->green.offset = 5; | |
467 p->green.length = 5; | |
468 p->blue.offset = 0; | |
469 p->blue.length = 5; | |
470 break; | |
471 } | |
472 } | |
473 | |
474 static void fb_mode2fb_vinfo(fb_mode_t *m, struct fb_var_screeninfo *v) | |
475 { | |
476 v->xres = m->xres; | |
477 v->yres = m->yres; | |
478 v->xres_virtual = m->vxres; | |
479 v->yres_virtual = m->vyres; | |
480 set_bpp(v, m->depth); | |
481 v->pixclock = m->pixclock; | |
482 v->left_margin = m->left; | |
483 v->right_margin = m->right; | |
484 v->upper_margin = m->upper; | |
485 v->lower_margin = m->lower; | |
486 v->hsync_len = m->hslen; | |
487 v->vsync_len = m->vslen; | |
488 v->sync = m->sync; | |
489 v->vmode = m->vmode; | |
490 } | |
491 | |
492 static range_t *str2range(char *s) | |
493 { | |
494 float tmp_min, tmp_max; | |
495 char *endptr = s; // to start the loop | |
496 range_t *r = NULL; | |
497 int i, j; | |
498 | |
499 if (!s) | |
500 return NULL; | |
501 for (i = 0; *endptr; i++) { | |
502 if (*s == ',') | |
503 goto out_err; | |
504 if (!(r = (range_t *) realloc(r, sizeof(*r) * i + 2))) { | |
505 printf("can't realloc 'r'\n"); | |
506 return NULL; | |
507 } | |
508 tmp_min = strtod(s, &endptr); | |
509 if (*endptr == 'k' || *endptr == 'K') { | |
510 tmp_min *= 1000.0; | |
511 endptr++; | |
512 } else if (*endptr == 'm' || *endptr == 'M') { | |
513 tmp_min *= 1000000.0; | |
514 endptr++; | |
515 } | |
516 if (*endptr == '-') { | |
517 tmp_max = strtod(endptr + 1, &endptr); | |
518 if (*endptr == 'k' || *endptr == 'K') { | |
519 tmp_max *= 1000.0; | |
520 endptr++; | |
521 } else if (*endptr == 'm' || *endptr == 'M') { | |
522 tmp_max *= 1000000.0; | |
523 endptr++; | |
524 } | |
525 if (*endptr != ',' && *endptr) | |
526 goto out_err; | |
527 } else if (*endptr == ',' || !*endptr) { | |
528 tmp_max = tmp_min; | |
529 } else | |
530 goto out_err; | |
531 r[i].min = tmp_min; | |
532 r[i].max = tmp_max; | |
533 s = endptr + 1; | |
534 } | |
535 /* check if we have negative numbers... */ | |
536 for (j = 0; j < i; j++) | |
537 if (r[j].min < 0 || r[j].max < 0) | |
538 goto out_err; | |
539 r[i].min = r[i].max = -1; | |
540 return r; | |
541 out_err: | |
542 if (r) | |
543 free(r); | |
544 return NULL; | |
545 } | |
546 | |
359 | 547 /****************************** |
548 * vo_fbdev * | |
549 ******************************/ | |
550 | |
393 | 551 /* |
552 * command line/config file options | |
553 */ | |
554 char *fb_dev_name = NULL; | |
555 char *fb_mode_cfgfile = "/etc/fb.modes"; | |
556 char *fb_mode_name = NULL; | |
418 | 557 char *monitor_hfreq_str = NULL; |
558 char *monitor_vfreq_str = NULL; | |
559 char *monitor_dotclock_str = NULL; | |
560 | |
561 range_t *monitor_hfreq = NULL; | |
562 range_t *monitor_vfreq = NULL; | |
563 range_t *monitor_dotclock = NULL; | |
393 | 564 |
565 static int fb_preinit_done = 0; | |
359 | 566 static int fb_works = 0; |
225 | 567 static int fb_dev_fd; |
568 static size_t fb_size; | |
569 static uint8_t *frame_buffer; | |
519 | 570 static uint8_t *L123123875; /* thx to .so */ |
359 | 571 static struct fb_fix_screeninfo fb_finfo; |
572 static struct fb_var_screeninfo fb_orig_vinfo; | |
573 static struct fb_var_screeninfo fb_vinfo; | |
481 | 574 static struct fb_cmap fb_oldcmap; |
575 static int fb_cmap_changed = 0; | |
359 | 576 static int fb_pixel_size; // 32: 4 24: 3 16: 2 15: 2 |
577 static int fb_real_bpp; // 32: 24 24: 24 16: 16 15: 15 | |
578 static int fb_bpp; // 32: 32 24: 24 16: 16 15: 15 | |
393 | 579 static int fb_bpp_we_want; // 32: 32 24: 24 16: 16 15: 15 |
359 | 580 static int fb_screen_width; |
581 static fb_mode_t *fb_mode = NULL; | |
582 | |
418 | 583 static int left_band_width; |
584 static int right_band_width; | |
585 static int upper_band_height; | |
586 static int lower_band_height; | |
359 | 587 static uint8_t *next_frame; |
225 | 588 static int in_width; |
589 static int in_height; | |
590 static int out_width; | |
591 static int out_height; | |
592 static uint32_t pixel_format; | |
593 | |
305 | 594 /* |
595 * Note: this function is completely cut'n'pasted from | |
596 * Chris Lawrence's code. | |
311 | 597 * (modified a bit to fit in my code...) |
305 | 598 */ |
599 struct fb_cmap *make_directcolor_cmap(struct fb_var_screeninfo *var) | |
600 { | |
601 /* Hopefully any DIRECTCOLOR device will have a big enough palette | |
602 * to handle mapping the full color depth. | |
603 * e.g. 8 bpp -> 256 entry palette | |
604 * | |
605 * We could handle some sort of gamma here | |
606 */ | |
607 int i, cols, rcols, gcols, bcols; | |
608 uint16_t *red, *green, *blue; | |
609 struct fb_cmap *cmap; | |
610 | |
611 rcols = 1 << var->red.length; | |
612 gcols = 1 << var->green.length; | |
613 bcols = 1 << var->blue.length; | |
614 | |
615 /* Make our palette the length of the deepest color */ | |
616 cols = (rcols > gcols ? rcols : gcols); | |
617 cols = (cols > bcols ? cols : bcols); | |
618 | |
619 red = malloc(cols * sizeof(red[0])); | |
620 if(!red) { | |
621 printf("Can't allocate red palette with %d entries.\n", cols); | |
622 return NULL; | |
623 } | |
624 for(i=0; i< rcols; i++) | |
625 red[i] = (65535/(rcols-1)) * i; | |
626 | |
627 green = malloc(cols * sizeof(green[0])); | |
628 if(!green) { | |
629 printf("Can't allocate green palette with %d entries.\n", cols); | |
630 free(red); | |
631 return NULL; | |
632 } | |
633 for(i=0; i< gcols; i++) | |
634 green[i] = (65535/(gcols-1)) * i; | |
635 | |
636 blue = malloc(cols * sizeof(blue[0])); | |
637 if(!blue) { | |
638 printf("Can't allocate blue palette with %d entries.\n", cols); | |
639 free(red); | |
640 free(green); | |
641 return NULL; | |
642 } | |
643 for(i=0; i< bcols; i++) | |
644 blue[i] = (65535/(bcols-1)) * i; | |
645 | |
646 cmap = malloc(sizeof(struct fb_cmap)); | |
647 if(!cmap) { | |
648 printf("Can't allocate color map\n"); | |
649 free(red); | |
650 free(green); | |
651 free(blue); | |
652 return NULL; | |
653 } | |
654 cmap->start = 0; | |
655 cmap->transp = 0; | |
656 cmap->len = cols; | |
657 cmap->red = red; | |
658 cmap->blue = blue; | |
659 cmap->green = green; | |
660 cmap->transp = NULL; | |
661 | |
662 return cmap; | |
663 } | |
225 | 664 |
393 | 665 static int fb_preinit(void) |
225 | 666 { |
393 | 667 if (!fb_dev_name && !(fb_dev_name = getenv("FRAMEBUFFER"))) |
668 fb_dev_name = "/dev/fb0"; | |
669 if (verbose > 0) | |
670 printf(FBDEV "using %s\n", fb_dev_name); | |
225 | 671 |
393 | 672 if ((fb_dev_fd = open(fb_dev_name, O_RDWR)) == -1) { |
673 printf(FBDEV "Can't open %s: %s\n", fb_dev_name, strerror(errno)); | |
674 goto err_out; | |
675 } | |
676 if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { | |
677 printf(FBDEV "Can't get VSCREENINFO: %s\n", strerror(errno)); | |
678 goto err_out_fd; | |
679 } | |
418 | 680 fb_orig_vinfo = fb_vinfo; |
393 | 681 |
682 fb_bpp = (fb_vinfo.bits_per_pixel == 32) ? 32 : | |
683 (fb_vinfo.red.length + fb_vinfo.green.length + | |
684 fb_vinfo.blue.length); | |
418 | 685 if (vo_dbpp) { |
686 if (vo_dbpp != 15 && vo_dbpp != 16 && vo_dbpp != 24 && | |
687 vo_dbpp != 32) { | |
688 printf(FBDEV "can't switch to %d bpp\n", vo_dbpp); | |
383 | 689 goto err_out; |
359 | 690 } |
418 | 691 fb_bpp = vo_dbpp; |
359 | 692 } |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
693 |
393 | 694 fb_preinit_done = 1; |
695 fb_works = 1; | |
696 return 0; | |
697 err_out_fd: | |
698 close(fb_dev_fd); | |
699 fb_dev_fd = -1; | |
700 err_out: | |
701 fb_preinit_done = 1; | |
702 return 1; | |
703 } | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
704 |
519 | 705 static void clear_bg(void) |
706 { | |
707 int i, offset = 0; | |
708 | |
709 for (i = 0; i < out_height; i++, offset += fb_screen_width) | |
710 memset(frame_buffer + offset, 0x0, out_width * fb_pixel_size); | |
711 } | |
418 | 712 |
393 | 713 static uint32_t init(uint32_t width, uint32_t height, uint32_t d_width, |
714 uint32_t d_height, uint32_t fullscreen, char *title, | |
715 uint32_t format) | |
716 { | |
418 | 717 #define FS (fullscreen & 0x01) |
718 #define VM (fullscreen & 0x02) | |
719 #define ZOOM (fullscreen & 0x04) | |
720 | |
393 | 721 struct fb_cmap *cmap; |
722 | |
723 if (!fb_preinit_done) | |
724 if (fb_preinit()) | |
725 return 1; | |
726 if (!fb_works) | |
727 return 1; | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
728 |
418 | 729 if (ZOOM) { |
730 printf(FBDEV "-zoom is not supported\n"); | |
731 return 1; | |
732 } | |
733 if (fb_mode_name && !VM) { | |
734 printf(FBDEV "-fbmode can be used only with -vm" | |
735 " (is it the right behaviour?)\n"); | |
736 return 1; | |
737 } | |
738 if (VM) | |
739 if (parse_fbmode_cfg(fb_mode_cfgfile) < 0) | |
740 return 1; | |
741 if ((!d_width + !d_height) == 1) { | |
742 printf(FBDEV "use both -x and -y, or none of them\n"); | |
743 return 1; | |
744 } | |
745 if (d_width) { | |
746 out_width = d_width; | |
747 out_height = d_height; | |
748 } else { | |
749 out_width = width; | |
750 out_height = height; | |
751 } | |
752 in_width = width; | |
753 in_height = height; | |
754 pixel_format = format; | |
755 | |
393 | 756 if (fb_mode_name) { |
418 | 757 if (!(fb_mode = find_mode_by_name(fb_mode_name))) { |
758 printf(FBDEV "can't find requested video mode\n"); | |
759 return 1; | |
760 } | |
761 fb_mode2fb_vinfo(fb_mode, &fb_vinfo); | |
762 } else if (VM) { | |
763 monitor_hfreq = str2range(monitor_hfreq_str); | |
764 monitor_vfreq = str2range(monitor_vfreq_str); | |
765 monitor_dotclock = str2range(monitor_dotclock_str); | |
766 if (!monitor_hfreq || !monitor_vfreq || !monitor_dotclock) { | |
767 printf(FBDEV "you have to specify the capabilities of" | |
768 " the monitor.\n"); | |
769 return 1; | |
770 } | |
771 if (!(fb_mode = find_best_mode(out_width, out_height, | |
772 monitor_hfreq, monitor_vfreq, | |
773 monitor_dotclock))) { | |
774 printf(FBDEV "can't find best video mode\n"); | |
775 return 1; | |
776 } | |
519 | 777 printf(FBDEV "using mode %dx%d @ %.1fHz\n", fb_mode->xres, |
778 fb_mode->yres, vsf(fb_mode)); | |
418 | 779 fb_mode2fb_vinfo(fb_mode, &fb_vinfo); |
359 | 780 } |
418 | 781 fb_bpp_we_want = fb_bpp; |
782 set_bpp(&fb_vinfo, fb_bpp); | |
359 | 783 fb_vinfo.xres_virtual = fb_vinfo.xres; |
784 fb_vinfo.yres_virtual = fb_vinfo.yres; | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
785 |
359 | 786 if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_vinfo)) { |
393 | 787 printf(FBDEV "Can't put VSCREENINFO: %s\n", strerror(errno)); |
788 return 1; | |
789 } | |
790 if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) { | |
791 printf(FBDEV "Can't get VSCREENINFO: %s\n", strerror(errno)); | |
792 return 1; | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
793 } |
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
794 |
393 | 795 if (verbose > 0) { |
796 printf(FBDEV "var info:\n"); | |
519 | 797 printf(FBDEV "xres: %u\n", fb_vinfo.xres); |
798 printf(FBDEV "yres: %u\n", fb_vinfo.yres); | |
799 printf(FBDEV "xres_virtual: %u\n", fb_vinfo.xres_virtual); | |
800 printf(FBDEV "yres_virtual: %u\n", fb_vinfo.yres_virtual); | |
801 printf(FBDEV "xoffset: %u\n", fb_vinfo.xoffset); | |
802 printf(FBDEV "yoffset: %u\n", fb_vinfo.yoffset); | |
803 printf(FBDEV "bits_per_pixel: %u\n", fb_vinfo.bits_per_pixel); | |
804 printf(FBDEV "grayscale: %u\n", fb_vinfo.grayscale); | |
393 | 805 printf(FBDEV "red: %lu %lu %lu\n", |
806 (unsigned long) fb_vinfo.red.offset, | |
807 (unsigned long) fb_vinfo.red.length, | |
808 (unsigned long) fb_vinfo.red.msb_right); | |
809 printf(FBDEV "green: %lu %lu %lu\n", | |
810 (unsigned long) fb_vinfo.green.offset, | |
811 (unsigned long) fb_vinfo.green.length, | |
812 (unsigned long) fb_vinfo.green.msb_right); | |
813 printf(FBDEV "blue: %lu %lu %lu\n", | |
814 (unsigned long) fb_vinfo.blue.offset, | |
815 (unsigned long) fb_vinfo.blue.length, | |
816 (unsigned long) fb_vinfo.blue.msb_right); | |
817 printf(FBDEV "transp: %lu %lu %lu\n", | |
818 (unsigned long) fb_vinfo.transp.offset, | |
819 (unsigned long) fb_vinfo.transp.length, | |
820 (unsigned long) fb_vinfo.transp.msb_right); | |
519 | 821 printf(FBDEV "nonstd: %u\n", fb_vinfo.nonstd); |
393 | 822 if (verbose > 1) { |
519 | 823 printf(FBDEV "activate: %u\n", fb_vinfo.activate); |
824 printf(FBDEV "height: %u\n", fb_vinfo.height); | |
825 printf(FBDEV "width: %u\n", fb_vinfo.width); | |
826 printf(FBDEV "accel_flags: %u\n", fb_vinfo.accel_flags); | |
393 | 827 printf(FBDEV "timing:\n"); |
519 | 828 printf(FBDEV "pixclock: %u\n", fb_vinfo.pixclock); |
829 printf(FBDEV "left_margin: %u\n", fb_vinfo.left_margin); | |
830 printf(FBDEV "right_margin: %u\n", fb_vinfo.right_margin); | |
831 printf(FBDEV "upper_margin: %u\n", fb_vinfo.upper_margin); | |
832 printf(FBDEV "lower_margin: %u\n", fb_vinfo.lower_margin); | |
833 printf(FBDEV "hsync_len: %u\n", fb_vinfo.hsync_len); | |
834 printf(FBDEV "vsync_len: %u\n", fb_vinfo.vsync_len); | |
835 printf(FBDEV "sync: %u\n", fb_vinfo.sync); | |
836 printf(FBDEV "vmode: %u\n", fb_vinfo.vmode); | |
393 | 837 } |
838 } | |
359 | 839 if (ioctl(fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo)) { |
393 | 840 printf(FBDEV "Can't get FSCREENINFO: %s\n", strerror(errno)); |
225 | 841 return 1; |
842 } | |
393 | 843 if (verbose > 0) { |
844 printf(FBDEV "fix info:\n"); | |
845 if (verbose > 1) { | |
846 printf(FBDEV "id: %.16s\n", fb_finfo.id); | |
847 printf(FBDEV "smem_start: %p\n", (void *) fb_finfo.smem_start); | |
848 } | |
519 | 849 printf(FBDEV "framebuffer size: %d bytes\n", fb_finfo.smem_len); |
393 | 850 printf(FBDEV "type: %lu\n", (unsigned long) fb_finfo.type); |
851 printf(FBDEV "type_aux: %lu\n", (unsigned long) fb_finfo.type_aux); | |
852 printf(FBDEV "visual: %lu\n", (unsigned long) fb_finfo.visual); | |
853 if (verbose > 1) { | |
854 printf(FBDEV "xpanstep: %u\n", fb_finfo.xpanstep); | |
855 printf(FBDEV "ypanstep: %u\n", fb_finfo.ypanstep); | |
856 printf(FBDEV "ywrapstep: %u\n", fb_finfo.ywrapstep); | |
857 } | |
858 printf(FBDEV "line_length: %lu bytes\n", (unsigned long) fb_finfo.line_length); | |
859 if (verbose > 1) { | |
860 printf(FBDEV "mmio_start: %p\n", (void *) fb_finfo.mmio_start); | |
519 | 861 printf(FBDEV "mmio_len: %u bytes\n", fb_finfo.mmio_len); |
862 printf(FBDEV "accel: %u\n", fb_finfo.accel); | |
393 | 863 } |
864 } | |
359 | 865 switch (fb_finfo.type) { |
225 | 866 case FB_TYPE_VGA_PLANES: |
393 | 867 printf(FBDEV "FB_TYPE_VGA_PLANES not supported.\n"); |
868 return 1; | |
225 | 869 case FB_TYPE_PLANES: |
393 | 870 printf(FBDEV "FB_TYPE_PLANES not supported.\n"); |
871 return 1; | |
225 | 872 case FB_TYPE_INTERLEAVED_PLANES: |
393 | 873 printf(FBDEV "FB_TYPE_INTERLEAVED_PLANES not supported.\n"); |
874 return 1; | |
225 | 875 #ifdef FB_TYPE_TEXT |
876 case FB_TYPE_TEXT: | |
393 | 877 printf(FBDEV "FB_TYPE_TEXT not supported.\n"); |
878 return 1; | |
225 | 879 #endif |
880 case FB_TYPE_PACKED_PIXELS: | |
881 /* OK */ | |
379 | 882 if (verbose > 0) |
393 | 883 printf(FBDEV "FB_TYPE_PACKED_PIXELS: OK\n"); |
225 | 884 break; |
885 default: | |
393 | 886 printf(FBDEV "unknown FB_TYPE: %d\n", fb_finfo.type); |
887 return 1; | |
305 | 888 } |
379 | 889 switch (fb_finfo.visual) { |
393 | 890 case FB_VISUAL_TRUECOLOR: |
891 break; | |
892 case FB_VISUAL_DIRECTCOLOR: | |
893 if (verbose > 0) | |
894 printf(FBDEV "creating cmap for directcolor\n"); | |
481 | 895 if (ioctl(fb_dev_fd, FBIOGETCMAP, &fb_oldcmap)) { |
393 | 896 printf(FBDEV "can't get cmap: %s\n", |
897 strerror(errno)); | |
898 return 1; | |
899 } | |
900 if (!(cmap = make_directcolor_cmap(&fb_vinfo))) | |
901 return 1; | |
902 if (ioctl(fb_dev_fd, FBIOPUTCMAP, cmap)) { | |
903 printf(FBDEV "can't put cmap: %s\n", | |
904 strerror(errno)); | |
905 return 1; | |
906 } | |
481 | 907 fb_cmap_changed = 1; |
393 | 908 free(cmap->red); |
909 free(cmap->green); | |
910 free(cmap->blue); | |
911 free(cmap); | |
912 break; | |
913 case FB_VISUAL_PSEUDOCOLOR: | |
914 printf(FBDEV "visual is FB_VISUAL_PSEUDOCOLOR." | |
915 "it's not tested!\n"); | |
916 break; | |
917 default: | |
918 printf(FBDEV "visual: %d not yet supported\n", | |
919 fb_finfo.visual); | |
920 return 1; | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
921 } |
418 | 922 if (FS || (d_width && VM)) { |
923 out_width = fb_vinfo.xres; | |
924 out_height = fb_vinfo.yres; | |
925 } | |
926 if (out_width < in_width || out_height < in_height) { | |
927 printf(FBDEV "screensize is smaller than video size\n"); | |
928 return 1; | |
929 } | |
245
cb4c682746c0
disabled scrollback buffer (virtual fb size set to real screen size)
szabii
parents:
231
diff
changeset
|
930 |
359 | 931 fb_pixel_size = fb_vinfo.bits_per_pixel / 8; |
932 fb_real_bpp = fb_vinfo.red.length + fb_vinfo.green.length + | |
933 fb_vinfo.blue.length; | |
934 fb_bpp = (fb_pixel_size == 4) ? 32 : fb_real_bpp; | |
393 | 935 if (fb_bpp_we_want != fb_bpp) |
418 | 936 printf(FBDEV "requested %d bpp, got %d bpp)!!!\n", |
393 | 937 fb_bpp_we_want, fb_bpp); |
359 | 938 fb_screen_width = fb_finfo.line_length; |
939 fb_size = fb_finfo.smem_len; | |
225 | 940 if ((frame_buffer = (uint8_t *) mmap(0, fb_size, PROT_READ | PROT_WRITE, |
941 MAP_SHARED, fb_dev_fd, 0)) == (uint8_t *) -1) { | |
393 | 942 printf(FBDEV "Can't mmap %s: %s\n", fb_dev_name, strerror(errno)); |
943 return 1; | |
225 | 944 } |
519 | 945 L123123875 = frame_buffer + (out_width - in_width) * fb_pixel_size / |
946 2 + (out_height - in_height) * fb_screen_width / 2; | |
229 | 947 |
393 | 948 if (verbose > 0) { |
949 printf(FBDEV "other:\n"); | |
519 | 950 if (verbose > 1) { |
393 | 951 printf(FBDEV "frame_buffer @ %p\n", frame_buffer); |
519 | 952 printf(FBDEV "L123123875 @ %p\n", L123123875); |
953 } | |
393 | 954 printf(FBDEV "fb_bpp: %d\n", fb_bpp); |
955 printf(FBDEV "fb_real_bpp: %d\n", fb_real_bpp); | |
956 printf(FBDEV "fb_pixel_size: %d bytes\n", fb_pixel_size); | |
957 printf(FBDEV "pixel per line: %d\n", fb_screen_width / fb_pixel_size); | |
379 | 958 } |
225 | 959 |
278 | 960 if (!(next_frame = (uint8_t *) malloc(in_width * in_height * fb_pixel_size))) { |
393 | 961 printf(FBDEV "Can't malloc next_frame: %s\n", strerror(errno)); |
225 | 962 return 1; |
963 } | |
964 | |
965 if (format == IMGFMT_YV12) | |
359 | 966 yuv2rgb_init(fb_bpp, MODE_RGB); |
519 | 967 clear_bg(); |
225 | 968 return 0; |
969 } | |
970 | |
971 static uint32_t query_format(uint32_t format) | |
972 { | |
519 | 973 int ret = 0x4; /* osd/sub supported on all bpp */ |
974 | |
393 | 975 if (!fb_preinit_done) |
976 if (fb_preinit()) | |
229 | 977 return 0; |
305 | 978 if (!fb_works) |
979 return 0; | |
980 | |
311 | 981 if ((format & IMGFMT_BGR_MASK) == IMGFMT_BGR) { |
982 int bpp = format & 0xff; | |
519 | 983 |
359 | 984 if (bpp == fb_bpp) |
519 | 985 return ret|0x2; |
359 | 986 else if (bpp == 15 && fb_bpp == 16) |
519 | 987 return ret|0x1; |
359 | 988 else if (bpp == 24 && fb_bpp == 32) |
519 | 989 return ret|0x1; |
311 | 990 } |
991 if (format == IMGFMT_YV12) | |
519 | 992 return ret|0x2; |
311 | 993 return 0; |
225 | 994 } |
995 | |
996 static const vo_info_t *get_info(void) | |
997 { | |
998 return &vo_info; | |
999 } | |
1000 | |
393 | 1001 extern void vo_draw_alpha_rgb32(int w, int h, unsigned char* src, |
1002 unsigned char *srca, int srcstride, unsigned char* dstbase, | |
1003 int dststride); | |
1004 extern void vo_draw_alpha_rgb24(int w, int h, unsigned char* src, | |
1005 unsigned char *srca, int srcstride, unsigned char* dstbase, | |
1006 int dststride); | |
1007 extern void vo_draw_alpha_rgb16(int w, int h, unsigned char* src, | |
1008 unsigned char *srca, int srcstride, unsigned char* dstbase, | |
1009 int dststride); | |
1010 extern void vo_draw_alpha_rgb15(int w, int h, unsigned char* src, | |
1011 unsigned char *srca, int srcstride, unsigned char* dstbase, | |
1012 int dststride); | |
1013 | |
225 | 1014 static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, |
1015 unsigned char *srca, int stride) | |
1016 { | |
359 | 1017 uint8_t *dst = next_frame + (in_width * y0 + x0) * fb_pixel_size; |
1018 int dstride = in_width * fb_pixel_size; | |
1019 | |
519 | 1020 switch (fb_bpp) { |
359 | 1021 case 24: |
1022 vo_draw_alpha_rgb24(w, h, src, srca, stride, dst, dstride); | |
1023 break; | |
1024 case 32: | |
1025 vo_draw_alpha_rgb32(w, h, src, srca, stride, dst, dstride); | |
1026 break; | |
1027 case 15: | |
1028 vo_draw_alpha_rgb15(w, h, src, srca, stride, dst, dstride); | |
1029 break; | |
1030 case 16: | |
1031 vo_draw_alpha_rgb16(w, h, src, srca, stride, dst, dstride); | |
1032 break; | |
1033 } | |
225 | 1034 } |
1035 | |
1036 static uint32_t draw_frame(uint8_t *src[]) | |
1037 { | |
1038 if (pixel_format == IMGFMT_YV12) { | |
1039 yuv2rgb(next_frame, src[0], src[1], src[2], in_width, | |
278 | 1040 in_height, in_width * fb_pixel_size, |
225 | 1041 in_width, in_width / 2); |
311 | 1042 } else { |
1043 int sbpp = ((pixel_format & 0xff) + 7) / 8; | |
1044 char *d = next_frame; | |
1045 char *s = src[0]; | |
1046 if (sbpp == fb_pixel_size) { | |
359 | 1047 if (fb_real_bpp == 16 && pixel_format == (IMGFMT_BGR|15)) { |
311 | 1048 #ifdef HAVE_MMX |
1049 rgb15to16_mmx(s, d, 2 * in_width * in_height); | |
1050 #else | |
1051 unsigned short *s1 = (unsigned short *) s; | |
1052 unsigned short *d1 = (unsigned short *) d; | |
1053 unsigned short *e = s1 + in_width * in_height; | |
1054 while (s1<e) { | |
1055 register x = *(s1++); | |
1056 *(d1++) = (x&0x001f)|((x&0x7fe0)<<1); | |
1057 } | |
1058 #endif | |
1059 } else | |
1060 memcpy(d, s, sbpp * in_width * in_height); | |
1061 } | |
1062 } | |
225 | 1063 return 0; |
1064 } | |
1065 | |
1066 static uint32_t draw_slice(uint8_t *src[], int stride[], int w, int h, int x, | |
1067 int y) | |
1068 { | |
1069 uint8_t *dest; | |
1070 | |
278 | 1071 dest = next_frame + (in_width * y + x) * fb_pixel_size; |
1072 yuv2rgb(dest, src[0], src[1], src[2], w, h, in_width * fb_pixel_size, | |
225 | 1073 stride[0], stride[1]); |
1074 return 0; | |
1075 } | |
1076 | |
1077 static void check_events(void) | |
1078 { | |
1079 } | |
1080 | |
519 | 1081 static void put_frame(void) |
225 | 1082 { |
1083 int i, out_offset = 0, in_offset = 0; | |
1084 | |
1085 for (i = 0; i < in_height; i++) { | |
519 | 1086 memcpy(L123123875 + out_offset, next_frame + in_offset, |
423 | 1087 in_width * fb_pixel_size); |
359 | 1088 out_offset += fb_screen_width; |
278 | 1089 in_offset += in_width * fb_pixel_size; |
225 | 1090 } |
1091 } | |
1092 | |
393 | 1093 extern void vo_draw_text(int dxs, int dys, void (*draw_alpha)(int x0, int y0, |
1094 int w, int h, unsigned char *src, unsigned char *srca, | |
1095 int stride)); | |
1096 | |
246 | 1097 static void flip_page(void) |
1098 { | |
1099 vo_draw_text(in_width, in_height, draw_alpha); | |
1100 check_events(); | |
519 | 1101 put_frame(); |
246 | 1102 } |
1103 | |
225 | 1104 static void uninit(void) |
1105 { | |
379 | 1106 if (verbose > 0) |
393 | 1107 printf(FBDEV "uninit\n"); |
481 | 1108 if (fb_cmap_changed) { |
1109 if (ioctl(fb_dev_fd, FBIOPUTCMAP, &fb_oldcmap)) | |
393 | 1110 printf(FBDEV "Can't restore original cmap\n"); |
481 | 1111 fb_cmap_changed = 0; |
306 | 1112 } |
503 | 1113 free(next_frame); |
1114 if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo)) | |
1115 printf(FBDEV "ioctl FBIOGET_VSCREENINFO: %s\n", strerror(errno)); | |
1116 fb_orig_vinfo.xoffset = fb_vinfo.xoffset; | |
1117 fb_orig_vinfo.yoffset = fb_vinfo.yoffset; | |
379 | 1118 if (ioctl(fb_dev_fd, FBIOPUT_VSCREENINFO, &fb_orig_vinfo)) |
503 | 1119 printf(FBDEV "Can't reset original fb_var_screeninfo: %s\n", strerror(errno)); |
359 | 1120 close(fb_dev_fd); |
225 | 1121 munmap(frame_buffer, fb_size); |
1122 } |