The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Dima Zavin | 4daf48a | 2011-08-30 11:59:20 -0700 | [diff] [blame] | 17 | #include <stdbool.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 18 | #include <stdlib.h> |
| 19 | #include <unistd.h> |
| 20 | |
| 21 | #include <fcntl.h> |
| 22 | #include <stdio.h> |
| 23 | |
| 24 | #include <sys/ioctl.h> |
| 25 | #include <sys/mman.h> |
| 26 | #include <sys/types.h> |
| 27 | |
| 28 | #include <linux/fb.h> |
| 29 | #include <linux/kd.h> |
| 30 | |
| 31 | #include <pixelflinger/pixelflinger.h> |
| 32 | |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 33 | #include "font_10x18.h" |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 34 | #include "minui.h" |
| 35 | |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 36 | #if defined(RECOVERY_BGRA) |
| 37 | #define PIXEL_FORMAT GGL_PIXEL_FORMAT_BGRA_8888 |
| 38 | #define PIXEL_SIZE 4 |
| 39 | #elif defined(RECOVERY_RGBX) |
Doug Zongker | be3e6f1 | 2011-01-13 16:43:44 -0800 | [diff] [blame] | 40 | #define PIXEL_FORMAT GGL_PIXEL_FORMAT_RGBX_8888 |
| 41 | #define PIXEL_SIZE 4 |
| 42 | #else |
| 43 | #define PIXEL_FORMAT GGL_PIXEL_FORMAT_RGB_565 |
| 44 | #define PIXEL_SIZE 2 |
| 45 | #endif |
| 46 | |
Devin Kim | 862d026 | 2012-07-19 10:47:34 -0700 | [diff] [blame] | 47 | #define NUM_BUFFERS 2 |
| 48 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 49 | typedef struct { |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 50 | GGLSurface* texture; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 51 | unsigned cwidth; |
| 52 | unsigned cheight; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 53 | } GRFont; |
| 54 | |
| 55 | static GRFont *gr_font = 0; |
| 56 | static GGLContext *gr_context = 0; |
| 57 | static GGLSurface gr_font_texture; |
Devin Kim | 862d026 | 2012-07-19 10:47:34 -0700 | [diff] [blame] | 58 | static GGLSurface gr_framebuffer[NUM_BUFFERS]; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 59 | static GGLSurface gr_mem_surface; |
| 60 | static unsigned gr_active_fb = 0; |
Octavian Purdila | 0e34880 | 2011-07-01 17:57:45 +0300 | [diff] [blame] | 61 | static unsigned double_buffering = 0; |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 62 | static int overscan_percent = OVERSCAN_PERCENT; |
| 63 | static int overscan_offset_x = 0; |
| 64 | static int overscan_offset_y = 0; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 65 | |
| 66 | static int gr_fb_fd = -1; |
| 67 | static int gr_vt_fd = -1; |
| 68 | |
| 69 | static struct fb_var_screeninfo vi; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 70 | static struct fb_fix_screeninfo fi; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 71 | |
| 72 | static int get_framebuffer(GGLSurface *fb) |
| 73 | { |
| 74 | int fd; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 75 | void *bits; |
| 76 | |
| 77 | fd = open("/dev/graphics/fb0", O_RDWR); |
| 78 | if (fd < 0) { |
| 79 | perror("cannot open fb0"); |
| 80 | return -1; |
| 81 | } |
| 82 | |
Michael Ward | 3dbe66b | 2011-06-23 19:28:53 -0700 | [diff] [blame] | 83 | if (ioctl(fd, FBIOGET_VSCREENINFO, &vi) < 0) { |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 84 | perror("failed to get fb0 info"); |
| 85 | close(fd); |
| 86 | return -1; |
| 87 | } |
| 88 | |
Michael Ward | 3dbe66b | 2011-06-23 19:28:53 -0700 | [diff] [blame] | 89 | vi.bits_per_pixel = PIXEL_SIZE * 8; |
| 90 | if (PIXEL_FORMAT == GGL_PIXEL_FORMAT_BGRA_8888) { |
| 91 | vi.red.offset = 8; |
| 92 | vi.red.length = 8; |
| 93 | vi.green.offset = 16; |
| 94 | vi.green.length = 8; |
| 95 | vi.blue.offset = 24; |
| 96 | vi.blue.length = 8; |
| 97 | vi.transp.offset = 0; |
| 98 | vi.transp.length = 8; |
| 99 | } else if (PIXEL_FORMAT == GGL_PIXEL_FORMAT_RGBX_8888) { |
| 100 | vi.red.offset = 24; |
| 101 | vi.red.length = 8; |
| 102 | vi.green.offset = 16; |
| 103 | vi.green.length = 8; |
| 104 | vi.blue.offset = 8; |
| 105 | vi.blue.length = 8; |
| 106 | vi.transp.offset = 0; |
| 107 | vi.transp.length = 8; |
| 108 | } else { /* RGB565*/ |
| 109 | vi.red.offset = 11; |
| 110 | vi.red.length = 5; |
| 111 | vi.green.offset = 5; |
| 112 | vi.green.length = 6; |
| 113 | vi.blue.offset = 0; |
| 114 | vi.blue.length = 5; |
| 115 | vi.transp.offset = 0; |
| 116 | vi.transp.length = 0; |
| 117 | } |
| 118 | if (ioctl(fd, FBIOPUT_VSCREENINFO, &vi) < 0) { |
| 119 | perror("failed to put fb0 info"); |
| 120 | close(fd); |
| 121 | return -1; |
| 122 | } |
| 123 | |
| 124 | if (ioctl(fd, FBIOGET_FSCREENINFO, &fi) < 0) { |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 125 | perror("failed to get fb0 info"); |
| 126 | close(fd); |
| 127 | return -1; |
| 128 | } |
| 129 | |
| 130 | bits = mmap(0, fi.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); |
| 131 | if (bits == MAP_FAILED) { |
| 132 | perror("failed to mmap framebuffer"); |
| 133 | close(fd); |
| 134 | return -1; |
| 135 | } |
| 136 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 137 | overscan_offset_x = vi.xres * overscan_percent / 100; |
| 138 | overscan_offset_y = vi.yres * overscan_percent / 100; |
| 139 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 140 | fb->version = sizeof(*fb); |
| 141 | fb->width = vi.xres; |
| 142 | fb->height = vi.yres; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 143 | fb->stride = fi.line_length/PIXEL_SIZE; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 144 | fb->data = bits; |
Doug Zongker | be3e6f1 | 2011-01-13 16:43:44 -0800 | [diff] [blame] | 145 | fb->format = PIXEL_FORMAT; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 146 | memset(fb->data, 0, vi.yres * fi.line_length); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 147 | |
| 148 | fb++; |
| 149 | |
Octavian Purdila | 0e34880 | 2011-07-01 17:57:45 +0300 | [diff] [blame] | 150 | /* check if we can use double buffering */ |
| 151 | if (vi.yres * fi.line_length * 2 > fi.smem_len) |
| 152 | return fd; |
| 153 | |
| 154 | double_buffering = 1; |
| 155 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 156 | fb->version = sizeof(*fb); |
| 157 | fb->width = vi.xres; |
| 158 | fb->height = vi.yres; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 159 | fb->stride = fi.line_length/PIXEL_SIZE; |
| 160 | fb->data = (void*) (((unsigned) bits) + vi.yres * fi.line_length); |
Doug Zongker | be3e6f1 | 2011-01-13 16:43:44 -0800 | [diff] [blame] | 161 | fb->format = PIXEL_FORMAT; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 162 | memset(fb->data, 0, vi.yres * fi.line_length); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 163 | |
| 164 | return fd; |
| 165 | } |
| 166 | |
| 167 | static void get_memory_surface(GGLSurface* ms) { |
| 168 | ms->version = sizeof(*ms); |
| 169 | ms->width = vi.xres; |
| 170 | ms->height = vi.yres; |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 171 | ms->stride = fi.line_length/PIXEL_SIZE; |
| 172 | ms->data = malloc(fi.line_length * vi.yres); |
Doug Zongker | be3e6f1 | 2011-01-13 16:43:44 -0800 | [diff] [blame] | 173 | ms->format = PIXEL_FORMAT; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | static void set_active_framebuffer(unsigned n) |
| 177 | { |
Octavian Purdila | 0e34880 | 2011-07-01 17:57:45 +0300 | [diff] [blame] | 178 | if (n > 1 || !double_buffering) return; |
Devin Kim | 862d026 | 2012-07-19 10:47:34 -0700 | [diff] [blame] | 179 | vi.yres_virtual = vi.yres * NUM_BUFFERS; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 180 | vi.yoffset = n * vi.yres; |
Doug Zongker | be3e6f1 | 2011-01-13 16:43:44 -0800 | [diff] [blame] | 181 | vi.bits_per_pixel = PIXEL_SIZE * 8; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 182 | if (ioctl(gr_fb_fd, FBIOPUT_VSCREENINFO, &vi) < 0) { |
| 183 | perror("active fb swap failed"); |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | void gr_flip(void) |
| 188 | { |
| 189 | GGLContext *gl = gr_context; |
| 190 | |
| 191 | /* swap front and back buffers */ |
Octavian Purdila | 0e34880 | 2011-07-01 17:57:45 +0300 | [diff] [blame] | 192 | if (double_buffering) |
| 193 | gr_active_fb = (gr_active_fb + 1) & 1; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 194 | |
| 195 | /* copy data from the in-memory surface to the buffer we're about |
| 196 | * to make active. */ |
| 197 | memcpy(gr_framebuffer[gr_active_fb].data, gr_mem_surface.data, |
Michael Ward | 9d1bcdf | 2011-06-22 14:30:34 -0700 | [diff] [blame] | 198 | fi.line_length * vi.yres); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 199 | |
| 200 | /* inform the display driver */ |
| 201 | set_active_framebuffer(gr_active_fb); |
| 202 | } |
| 203 | |
| 204 | void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a) |
| 205 | { |
| 206 | GGLContext *gl = gr_context; |
| 207 | GGLint color[4]; |
| 208 | color[0] = ((r << 8) | r) + 1; |
| 209 | color[1] = ((g << 8) | g) + 1; |
| 210 | color[2] = ((b << 8) | b) + 1; |
| 211 | color[3] = ((a << 8) | a) + 1; |
| 212 | gl->color4xv(gl, color); |
| 213 | } |
| 214 | |
| 215 | int gr_measure(const char *s) |
| 216 | { |
| 217 | return gr_font->cwidth * strlen(s); |
| 218 | } |
| 219 | |
Dima Zavin | 3c7f00e | 2011-08-30 11:58:24 -0700 | [diff] [blame] | 220 | void gr_font_size(int *x, int *y) |
| 221 | { |
| 222 | *x = gr_font->cwidth; |
| 223 | *y = gr_font->cheight; |
| 224 | } |
| 225 | |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 226 | int gr_text(int x, int y, const char *s, int bold) |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 227 | { |
| 228 | GGLContext *gl = gr_context; |
| 229 | GRFont *font = gr_font; |
| 230 | unsigned off; |
| 231 | |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 232 | if (!font->texture) return x; |
| 233 | |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 234 | bold = bold && (font->texture->height != font->cheight); |
| 235 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 236 | x += overscan_offset_x; |
| 237 | y += overscan_offset_y; |
| 238 | |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 239 | gl->bindTexture(gl, font->texture); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 240 | gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE); |
| 241 | gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 242 | gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 243 | gl->enable(gl, GGL_TEXTURE_2D); |
| 244 | |
| 245 | while((off = *s++)) { |
| 246 | off -= 32; |
| 247 | if (off < 96) { |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 248 | gl->texCoord2i(gl, (off * font->cwidth) - x, |
| 249 | (bold ? font->cheight : 0) - y); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 250 | gl->recti(gl, x, y, x + font->cwidth, y + font->cheight); |
| 251 | } |
| 252 | x += font->cwidth; |
| 253 | } |
| 254 | |
| 255 | return x; |
| 256 | } |
| 257 | |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 258 | void gr_texticon(int x, int y, gr_surface icon) { |
Doug Zongker | 52eeea4f | 2012-09-04 14:28:25 -0700 | [diff] [blame] | 259 | if (gr_context == NULL || icon == NULL) { |
| 260 | return; |
| 261 | } |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 262 | GGLContext* gl = gr_context; |
| 263 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 264 | x += overscan_offset_x; |
| 265 | y += overscan_offset_y; |
| 266 | |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 267 | gl->bindTexture(gl, (GGLSurface*) icon); |
| 268 | gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE); |
| 269 | gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 270 | gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 271 | gl->enable(gl, GGL_TEXTURE_2D); |
| 272 | |
| 273 | int w = gr_get_width(icon); |
| 274 | int h = gr_get_height(icon); |
| 275 | |
| 276 | gl->texCoord2i(gl, -x, -y); |
| 277 | gl->recti(gl, x, y, x+gr_get_width(icon), y+gr_get_height(icon)); |
| 278 | } |
| 279 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 280 | void gr_fill(int x1, int y1, int x2, int y2) |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 281 | { |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 282 | x1 += overscan_offset_x; |
| 283 | y1 += overscan_offset_y; |
| 284 | |
| 285 | x2 += overscan_offset_x; |
| 286 | y2 += overscan_offset_y; |
| 287 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 288 | GGLContext *gl = gr_context; |
| 289 | gl->disable(gl, GGL_TEXTURE_2D); |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 290 | gl->recti(gl, x1, y1, x2, y2); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 291 | } |
| 292 | |
| 293 | void gr_blit(gr_surface source, int sx, int sy, int w, int h, int dx, int dy) { |
Doug Zongker | 52eeea4f | 2012-09-04 14:28:25 -0700 | [diff] [blame] | 294 | if (gr_context == NULL || source == NULL) { |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 295 | return; |
| 296 | } |
| 297 | GGLContext *gl = gr_context; |
| 298 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 299 | dx += overscan_offset_x; |
| 300 | dy += overscan_offset_y; |
| 301 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 302 | gl->bindTexture(gl, (GGLSurface*) source); |
| 303 | gl->texEnvi(gl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE); |
| 304 | gl->texGeni(gl, GGL_S, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 305 | gl->texGeni(gl, GGL_T, GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE); |
| 306 | gl->enable(gl, GGL_TEXTURE_2D); |
| 307 | gl->texCoord2i(gl, sx - dx, sy - dy); |
| 308 | gl->recti(gl, dx, dy, dx + w, dy + h); |
| 309 | } |
| 310 | |
| 311 | unsigned int gr_get_width(gr_surface surface) { |
| 312 | if (surface == NULL) { |
| 313 | return 0; |
| 314 | } |
| 315 | return ((GGLSurface*) surface)->width; |
| 316 | } |
| 317 | |
| 318 | unsigned int gr_get_height(gr_surface surface) { |
| 319 | if (surface == NULL) { |
| 320 | return 0; |
| 321 | } |
| 322 | return ((GGLSurface*) surface)->height; |
| 323 | } |
| 324 | |
| 325 | static void gr_init_font(void) |
| 326 | { |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 327 | gr_font = calloc(sizeof(*gr_font), 1); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 328 | |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 329 | int res = res_create_surface("font", (void**)&(gr_font->texture)); |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 330 | if (res == 0) { |
| 331 | // The font image should be a 96x2 array of character images. The |
| 332 | // columns are the printable ASCII characters 0x20 - 0x7f. The |
| 333 | // top row is regular text; the bottom row is bold. |
| 334 | gr_font->cwidth = gr_font->texture->width / 96; |
| 335 | gr_font->cheight = gr_font->texture->height / 2; |
| 336 | } else { |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 337 | printf("failed to read font: res=%d\n", res); |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame^] | 338 | |
| 339 | // fall back to the compiled-in font. |
| 340 | gr_font->texture = malloc(sizeof(*gr_font->texture)); |
| 341 | gr_font->texture->width = font.width; |
| 342 | gr_font->texture->height = font.height; |
| 343 | gr_font->texture->stride = font.width; |
| 344 | |
| 345 | unsigned char* bits = malloc(font.width * font.height); |
| 346 | gr_font->texture->data = (void*) bits; |
| 347 | |
| 348 | unsigned char data; |
| 349 | unsigned char* in = font.rundata; |
| 350 | while((data = *in++)) { |
| 351 | memset(bits, (data & 0x80) ? 255 : 0, data & 0x7f); |
| 352 | bits += (data & 0x7f); |
| 353 | } |
| 354 | |
| 355 | gr_font->cwidth = font.cwidth; |
| 356 | gr_font->cheight = font.cheight; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 357 | } |
| 358 | |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 359 | // interpret the grayscale as alpha |
| 360 | gr_font->texture->format = GGL_PIXEL_FORMAT_A_8; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 361 | } |
| 362 | |
| 363 | int gr_init(void) |
| 364 | { |
| 365 | gglInit(&gr_context); |
| 366 | GGLContext *gl = gr_context; |
| 367 | |
| 368 | gr_init_font(); |
| 369 | gr_vt_fd = open("/dev/tty0", O_RDWR | O_SYNC); |
| 370 | if (gr_vt_fd < 0) { |
| 371 | // This is non-fatal; post-Cupcake kernels don't have tty0. |
| 372 | perror("can't open /dev/tty0"); |
| 373 | } else if (ioctl(gr_vt_fd, KDSETMODE, (void*) KD_GRAPHICS)) { |
| 374 | // However, if we do open tty0, we expect the ioctl to work. |
| 375 | perror("failed KDSETMODE to KD_GRAPHICS on tty0"); |
| 376 | gr_exit(); |
| 377 | return -1; |
| 378 | } |
| 379 | |
| 380 | gr_fb_fd = get_framebuffer(gr_framebuffer); |
| 381 | if (gr_fb_fd < 0) { |
| 382 | gr_exit(); |
| 383 | return -1; |
| 384 | } |
| 385 | |
| 386 | get_memory_surface(&gr_mem_surface); |
| 387 | |
| 388 | fprintf(stderr, "framebuffer: fd %d (%d x %d)\n", |
| 389 | gr_fb_fd, gr_framebuffer[0].width, gr_framebuffer[0].height); |
| 390 | |
| 391 | /* start with 0 as front (displayed) and 1 as back (drawing) */ |
| 392 | gr_active_fb = 0; |
| 393 | set_active_framebuffer(0); |
| 394 | gl->colorBuffer(gl, &gr_mem_surface); |
| 395 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 396 | gl->activeTexture(gl, 0); |
| 397 | gl->enable(gl, GGL_BLEND); |
| 398 | gl->blendFunc(gl, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA); |
| 399 | |
Doug Zongker | f6abd40 | 2011-09-27 13:09:48 -0700 | [diff] [blame] | 400 | gr_fb_blank(true); |
| 401 | gr_fb_blank(false); |
| 402 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 403 | return 0; |
| 404 | } |
| 405 | |
| 406 | void gr_exit(void) |
| 407 | { |
| 408 | close(gr_fb_fd); |
| 409 | gr_fb_fd = -1; |
| 410 | |
| 411 | free(gr_mem_surface.data); |
| 412 | |
| 413 | ioctl(gr_vt_fd, KDSETMODE, (void*) KD_TEXT); |
| 414 | close(gr_vt_fd); |
| 415 | gr_vt_fd = -1; |
| 416 | } |
| 417 | |
| 418 | int gr_fb_width(void) |
| 419 | { |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 420 | return gr_framebuffer[0].width - 2*overscan_offset_x; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 421 | } |
| 422 | |
| 423 | int gr_fb_height(void) |
| 424 | { |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 425 | return gr_framebuffer[0].height - 2*overscan_offset_y; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 426 | } |
| 427 | |
| 428 | gr_pixel *gr_fb_data(void) |
| 429 | { |
| 430 | return (unsigned short *) gr_mem_surface.data; |
| 431 | } |
Dima Zavin | 4daf48a | 2011-08-30 11:59:20 -0700 | [diff] [blame] | 432 | |
| 433 | void gr_fb_blank(bool blank) |
| 434 | { |
| 435 | int ret; |
| 436 | |
| 437 | ret = ioctl(gr_fb_fd, FBIOBLANK, blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK); |
| 438 | if (ret < 0) |
| 439 | perror("ioctl(): blank"); |
| 440 | } |