blob: d7d6e8d5a7e55919c0b177cdee432929d07959a7 [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
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 Zavin4daf48a2011-08-30 11:59:20 -070017#include <stdbool.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080018#include <stdlib.h>
Elliott Hughescd3c55a2015-01-29 20:50:08 -080019#include <string.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080020#include <unistd.h>
21
22#include <fcntl.h>
23#include <stdio.h>
24
25#include <sys/ioctl.h>
26#include <sys/mman.h>
27#include <sys/types.h>
28
29#include <linux/fb.h>
30#include <linux/kd.h>
31
Doug Zongker16f97c32014-03-06 16:16:05 -080032#include <time.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080033
Doug Zongker6fd59ac2013-03-06 15:01:11 -080034#include "font_10x18.h"
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080035#include "minui.h"
Doug Zongker5290f202014-03-11 13:22:04 -070036#include "graphics.h"
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080037
Elliott Hughes07cfb8f2015-04-10 13:12:05 -070038struct GRFont {
Doug Zongker16f97c32014-03-06 16:16:05 -080039 GRSurface* texture;
40 int cwidth;
41 int cheight;
Elliott Hughes07cfb8f2015-04-10 13:12:05 -070042};
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080043
Doug Zongker16f97c32014-03-06 16:16:05 -080044static GRFont* gr_font = NULL;
Doug Zongker5290f202014-03-11 13:22:04 -070045static minui_backend* gr_backend = NULL;
Doug Zongker16f97c32014-03-06 16:16:05 -080046
Doug Zongkerc560a672012-12-18 16:31:27 -080047static int overscan_percent = OVERSCAN_PERCENT;
48static int overscan_offset_x = 0;
49static int overscan_offset_y = 0;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080050
Doug Zongker16f97c32014-03-06 16:16:05 -080051static unsigned char gr_current_r = 255;
52static unsigned char gr_current_g = 255;
53static unsigned char gr_current_b = 255;
54static unsigned char gr_current_a = 255;
55
Doug Zongker5290f202014-03-11 13:22:04 -070056static GRSurface* gr_draw = NULL;
Doug Zongker16f97c32014-03-06 16:16:05 -080057
58static bool outside(int x, int y)
59{
60 return x < 0 || x >= gr_draw->width || y < 0 || y >= gr_draw->height;
61}
62
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080063int gr_measure(const char *s)
64{
65 return gr_font->cwidth * strlen(s);
66}
67
Dima Zavin3c7f00e2011-08-30 11:58:24 -070068void gr_font_size(int *x, int *y)
69{
70 *x = gr_font->cwidth;
71 *y = gr_font->cheight;
72}
73
Doug Zongker16f97c32014-03-06 16:16:05 -080074static void text_blend(unsigned char* src_p, int src_row_bytes,
75 unsigned char* dst_p, int dst_row_bytes,
76 int width, int height)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080077{
Elliott Hughes01a4d082015-03-24 15:21:48 -070078 for (int j = 0; j < height; ++j) {
Doug Zongker16f97c32014-03-06 16:16:05 -080079 unsigned char* sx = src_p;
80 unsigned char* px = dst_p;
Elliott Hughes01a4d082015-03-24 15:21:48 -070081 for (int i = 0; i < width; ++i) {
Doug Zongker16f97c32014-03-06 16:16:05 -080082 unsigned char a = *sx++;
83 if (gr_current_a < 255) a = ((int)a * gr_current_a) / 255;
84 if (a == 255) {
85 *px++ = gr_current_r;
86 *px++ = gr_current_g;
87 *px++ = gr_current_b;
88 px++;
89 } else if (a > 0) {
90 *px = (*px * (255-a) + gr_current_r * a) / 255;
91 ++px;
92 *px = (*px * (255-a) + gr_current_g * a) / 255;
93 ++px;
94 *px = (*px * (255-a) + gr_current_b * a) / 255;
95 ++px;
96 ++px;
97 } else {
98 px += 4;
99 }
100 }
101 src_p += src_row_bytes;
102 dst_p += dst_row_bytes;
103 }
104}
105
Doug Zongker16f97c32014-03-06 16:16:05 -0800106void gr_text(int x, int y, const char *s, int bold)
107{
Elliott Hughes01a4d082015-03-24 15:21:48 -0700108 GRFont* font = gr_font;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800109
Elliott Hughes01a4d082015-03-24 15:21:48 -0700110 if (!font->texture || gr_current_a == 0) return;
Doug Zongker55a36ac2013-03-04 15:49:02 -0800111
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800112 bold = bold && (font->texture->height != font->cheight);
113
Doug Zongkerc560a672012-12-18 16:31:27 -0800114 x += overscan_offset_x;
115 y += overscan_offset_y;
116
Elliott Hughes01a4d082015-03-24 15:21:48 -0700117 unsigned char ch;
118 while ((ch = *s++)) {
Doug Zongker16f97c32014-03-06 16:16:05 -0800119 if (outside(x, y) || outside(x+font->cwidth-1, y+font->cheight-1)) break;
Doug Zongker16f97c32014-03-06 16:16:05 -0800120
Elliott Hughes01a4d082015-03-24 15:21:48 -0700121 if (ch < ' ' || ch > '~') {
122 ch = '?';
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800123 }
Elliott Hughes01a4d082015-03-24 15:21:48 -0700124
125 unsigned char* src_p = font->texture->data + ((ch - ' ') * font->cwidth) +
126 (bold ? font->cheight * font->texture->row_bytes : 0);
127 unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
128
129 text_blend(src_p, font->texture->row_bytes,
130 dst_p, gr_draw->row_bytes,
131 font->cwidth, font->cheight);
132
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800133 x += font->cwidth;
134 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800135}
136
Doug Zongker16f97c32014-03-06 16:16:05 -0800137void gr_texticon(int x, int y, GRSurface* icon) {
138 if (icon == NULL) return;
139
140 if (icon->pixel_bytes != 1) {
141 printf("gr_texticon: source has wrong format\n");
Doug Zongker52eeea4f2012-09-04 14:28:25 -0700142 return;
143 }
Doug Zongker02ec6b82012-08-22 17:26:40 -0700144
Doug Zongkerc560a672012-12-18 16:31:27 -0800145 x += overscan_offset_x;
146 y += overscan_offset_y;
147
Doug Zongker16f97c32014-03-06 16:16:05 -0800148 if (outside(x, y) || outside(x+icon->width-1, y+icon->height-1)) return;
Doug Zongker02ec6b82012-08-22 17:26:40 -0700149
Doug Zongker16f97c32014-03-06 16:16:05 -0800150 unsigned char* src_p = icon->data;
151 unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
Doug Zongker02ec6b82012-08-22 17:26:40 -0700152
Doug Zongker16f97c32014-03-06 16:16:05 -0800153 text_blend(src_p, icon->row_bytes,
154 dst_p, gr_draw->row_bytes,
155 icon->width, icon->height);
156}
157
158void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
159{
Tony Kuofd778e32015-02-05 21:25:56 +0800160#if defined(RECOVERY_ABGR) || defined(RECOVERY_BGRA)
161 gr_current_r = b;
162 gr_current_g = g;
163 gr_current_b = r;
164 gr_current_a = a;
165#else
Doug Zongker16f97c32014-03-06 16:16:05 -0800166 gr_current_r = r;
167 gr_current_g = g;
168 gr_current_b = b;
169 gr_current_a = a;
Tony Kuofd778e32015-02-05 21:25:56 +0800170#endif
Doug Zongker16f97c32014-03-06 16:16:05 -0800171}
172
173void gr_clear()
174{
Elliott Hughes01a4d082015-03-24 15:21:48 -0700175 if (gr_current_r == gr_current_g && gr_current_r == gr_current_b) {
Doug Zongker16f97c32014-03-06 16:16:05 -0800176 memset(gr_draw->data, gr_current_r, gr_draw->height * gr_draw->row_bytes);
177 } else {
Doug Zongker16f97c32014-03-06 16:16:05 -0800178 unsigned char* px = gr_draw->data;
Elliott Hughes01a4d082015-03-24 15:21:48 -0700179 for (int y = 0; y < gr_draw->height; ++y) {
180 for (int x = 0; x < gr_draw->width; ++x) {
Doug Zongker16f97c32014-03-06 16:16:05 -0800181 *px++ = gr_current_r;
182 *px++ = gr_current_g;
183 *px++ = gr_current_b;
184 px++;
185 }
186 px += gr_draw->row_bytes - (gr_draw->width * gr_draw->pixel_bytes);
187 }
188 }
Doug Zongker02ec6b82012-08-22 17:26:40 -0700189}
190
Doug Zongkerc560a672012-12-18 16:31:27 -0800191void gr_fill(int x1, int y1, int x2, int y2)
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800192{
Doug Zongkerc560a672012-12-18 16:31:27 -0800193 x1 += overscan_offset_x;
194 y1 += overscan_offset_y;
195
196 x2 += overscan_offset_x;
197 y2 += overscan_offset_y;
198
Doug Zongker16f97c32014-03-06 16:16:05 -0800199 if (outside(x1, y1) || outside(x2-1, y2-1)) return;
200
201 unsigned char* p = gr_draw->data + y1 * gr_draw->row_bytes + x1 * gr_draw->pixel_bytes;
202 if (gr_current_a == 255) {
203 int x, y;
204 for (y = y1; y < y2; ++y) {
205 unsigned char* px = p;
206 for (x = x1; x < x2; ++x) {
207 *px++ = gr_current_r;
208 *px++ = gr_current_g;
209 *px++ = gr_current_b;
210 px++;
211 }
212 p += gr_draw->row_bytes;
213 }
214 } else if (gr_current_a > 0) {
215 int x, y;
216 for (y = y1; y < y2; ++y) {
217 unsigned char* px = p;
218 for (x = x1; x < x2; ++x) {
219 *px = (*px * (255-gr_current_a) + gr_current_r * gr_current_a) / 255;
220 ++px;
221 *px = (*px * (255-gr_current_a) + gr_current_g * gr_current_a) / 255;
222 ++px;
223 *px = (*px * (255-gr_current_a) + gr_current_b * gr_current_a) / 255;
224 ++px;
225 ++px;
226 }
227 p += gr_draw->row_bytes;
228 }
229 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800230}
231
Doug Zongker16f97c32014-03-06 16:16:05 -0800232void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
233 if (source == NULL) return;
234
235 if (gr_draw->pixel_bytes != source->pixel_bytes) {
236 printf("gr_blit: source has wrong format\n");
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800237 return;
238 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800239
Doug Zongkerc560a672012-12-18 16:31:27 -0800240 dx += overscan_offset_x;
241 dy += overscan_offset_y;
242
Doug Zongker16f97c32014-03-06 16:16:05 -0800243 if (outside(dx, dy) || outside(dx+w-1, dy+h-1)) return;
244
245 unsigned char* src_p = source->data + sy*source->row_bytes + sx*source->pixel_bytes;
246 unsigned char* dst_p = gr_draw->data + dy*gr_draw->row_bytes + dx*gr_draw->pixel_bytes;
247
248 int i;
249 for (i = 0; i < h; ++i) {
250 memcpy(dst_p, src_p, w * source->pixel_bytes);
251 src_p += source->row_bytes;
252 dst_p += gr_draw->row_bytes;
253 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800254}
255
Doug Zongker16f97c32014-03-06 16:16:05 -0800256unsigned int gr_get_width(GRSurface* surface) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800257 if (surface == NULL) {
258 return 0;
259 }
Doug Zongker16f97c32014-03-06 16:16:05 -0800260 return surface->width;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800261}
262
Doug Zongker16f97c32014-03-06 16:16:05 -0800263unsigned int gr_get_height(GRSurface* surface) {
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800264 if (surface == NULL) {
265 return 0;
266 }
Doug Zongker16f97c32014-03-06 16:16:05 -0800267 return surface->height;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800268}
269
270static void gr_init_font(void)
271{
Elliott Hughes07cfb8f2015-04-10 13:12:05 -0700272 gr_font = reinterpret_cast<GRFont*>(calloc(sizeof(*gr_font), 1));
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800273
Doug Zongkera418aa72014-03-17 12:10:02 -0700274 int res = res_create_alpha_surface("font", &(gr_font->texture));
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800275 if (res == 0) {
276 // The font image should be a 96x2 array of character images. The
277 // columns are the printable ASCII characters 0x20 - 0x7f. The
278 // top row is regular text; the bottom row is bold.
279 gr_font->cwidth = gr_font->texture->width / 96;
280 gr_font->cheight = gr_font->texture->height / 2;
281 } else {
Doug Zongker55a36ac2013-03-04 15:49:02 -0800282 printf("failed to read font: res=%d\n", res);
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800283
284 // fall back to the compiled-in font.
Elliott Hughes07cfb8f2015-04-10 13:12:05 -0700285 gr_font->texture = reinterpret_cast<GRSurface*>(malloc(sizeof(*gr_font->texture)));
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800286 gr_font->texture->width = font.width;
287 gr_font->texture->height = font.height;
Doug Zongker16f97c32014-03-06 16:16:05 -0800288 gr_font->texture->row_bytes = font.width;
289 gr_font->texture->pixel_bytes = 1;
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800290
Elliott Hughes07cfb8f2015-04-10 13:12:05 -0700291 unsigned char* bits = reinterpret_cast<unsigned char*>(malloc(font.width * font.height));
292 gr_font->texture->data = reinterpret_cast<unsigned char*>(bits);
Doug Zongker6fd59ac2013-03-06 15:01:11 -0800293
294 unsigned char data;
295 unsigned char* in = font.rundata;
296 while((data = *in++)) {
297 memset(bits, (data & 0x80) ? 255 : 0, data & 0x7f);
298 bits += (data & 0x7f);
299 }
300
301 gr_font->cwidth = font.cwidth;
302 gr_font->cheight = font.cheight;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800303 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800304}
305
Doug Zongker16f97c32014-03-06 16:16:05 -0800306#if 0
307// Exercises many of the gr_*() functions; useful for testing.
308static void gr_test() {
309 GRSurface** images;
310 int frames;
311 int result = res_create_multi_surface("icon_installing", &frames, &images);
312 if (result < 0) {
313 printf("create surface %d\n", result);
314 gr_exit();
315 return;
316 }
317
318 time_t start = time(NULL);
319 int x;
320 for (x = 0; x <= 1200; ++x) {
321 if (x < 400) {
322 gr_color(0, 0, 0, 255);
323 } else {
324 gr_color(0, (x-400)%128, 0, 255);
325 }
326 gr_clear();
327
328 gr_color(255, 0, 0, 255);
329 gr_surface frame = images[x%frames];
330 gr_blit(frame, 0, 0, frame->width, frame->height, x, 0);
331
332 gr_color(255, 0, 0, 128);
333 gr_fill(400, 150, 600, 350);
334
335 gr_color(255, 255, 255, 255);
336 gr_text(500, 225, "hello, world!", 0);
337 gr_color(255, 255, 0, 128);
338 gr_text(300+x, 275, "pack my box with five dozen liquor jugs", 1);
339
340 gr_color(0, 0, 255, 128);
341 gr_fill(gr_draw->width - 200 - x, 300, gr_draw->width - x, 500);
342
Doug Zongker5290f202014-03-11 13:22:04 -0700343 gr_draw = gr_backend->flip(gr_backend);
Doug Zongker16f97c32014-03-06 16:16:05 -0800344 }
345 printf("getting end time\n");
346 time_t end = time(NULL);
347 printf("got end time\n");
348 printf("start %ld end %ld\n", (long)start, (long)end);
349 if (end > start) {
350 printf("%.2f fps\n", ((double)x) / (end-start));
351 }
352}
353#endif
354
Doug Zongker5290f202014-03-11 13:22:04 -0700355void gr_flip() {
356 gr_draw = gr_backend->flip(gr_backend);
357}
358
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800359int gr_init(void)
360{
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800361 gr_init_font();
Doug Zongker16f97c32014-03-06 16:16:05 -0800362
Greg Hackmann41909dd2014-04-25 10:39:50 -0700363 gr_backend = open_adf();
364 if (gr_backend) {
365 gr_draw = gr_backend->init(gr_backend);
366 if (!gr_draw) {
367 gr_backend->exit(gr_backend);
368 }
369 }
370
371 if (!gr_draw) {
372 gr_backend = open_fbdev();
373 gr_draw = gr_backend->init(gr_backend);
374 if (gr_draw == NULL) {
375 return -1;
376 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800377 }
378
Doug Zongker5290f202014-03-11 13:22:04 -0700379 overscan_offset_x = gr_draw->width * overscan_percent / 100;
380 overscan_offset_y = gr_draw->height * overscan_percent / 100;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800381
Doug Zongker16f97c32014-03-06 16:16:05 -0800382 gr_flip();
383 gr_flip();
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800384
385 return 0;
386}
387
388void gr_exit(void)
389{
Doug Zongker5290f202014-03-11 13:22:04 -0700390 gr_backend->exit(gr_backend);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800391}
392
393int gr_fb_width(void)
394{
Doug Zongker16f97c32014-03-06 16:16:05 -0800395 return gr_draw->width - 2*overscan_offset_x;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800396}
397
398int gr_fb_height(void)
399{
Doug Zongker16f97c32014-03-06 16:16:05 -0800400 return gr_draw->height - 2*overscan_offset_y;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800401}
Dima Zavin4daf48a2011-08-30 11:59:20 -0700402
403void gr_fb_blank(bool blank)
404{
Doug Zongker5290f202014-03-11 13:22:04 -0700405 gr_backend->blank(gr_backend, blank);
Dima Zavin4daf48a2011-08-30 11:59:20 -0700406}