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 | |
Tao Bao | 0ecbd76 | 2017-01-16 21:16:58 -0800 | [diff] [blame] | 17 | #include "graphics.h" |
| 18 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 19 | #include <stdint.h> |
Tao Bao | e8020f4 | 2017-02-03 09:30:07 -0800 | [diff] [blame] | 20 | #include <stdio.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 21 | #include <stdlib.h> |
Elliott Hughes | cd3c55a | 2015-01-29 20:50:08 -0800 | [diff] [blame] | 22 | #include <string.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 23 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 24 | #include <memory> |
| 25 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 26 | #include "graphics_adf.h" |
| 27 | #include "graphics_drm.h" |
| 28 | #include "graphics_fbdev.h" |
Tao Bao | 0ecbd76 | 2017-01-16 21:16:58 -0800 | [diff] [blame] | 29 | #include "minui/minui.h" |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 30 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 31 | static GRFont* gr_font = nullptr; |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 32 | static MinuiBackend* gr_backend = nullptr; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 33 | |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 34 | static int overscan_percent = OVERSCAN_PERCENT; |
| 35 | static int overscan_offset_x = 0; |
| 36 | static int overscan_offset_y = 0; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 37 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 38 | static uint32_t gr_current = ~0; |
| 39 | static constexpr uint32_t alpha_mask = 0xff000000; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 40 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 41 | // gr_draw is owned by backends. |
| 42 | static const GRSurface* gr_draw = nullptr; |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 43 | static GRRotation rotation = GRRotation::NONE; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 44 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 45 | static bool outside(int x, int y) { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 46 | auto swapped = (rotation == GRRotation::LEFT || rotation == GRRotation::RIGHT); |
| 47 | return x < 0 || x >= (swapped ? gr_draw->height : gr_draw->width) || y < 0 || |
| 48 | y >= (swapped ? gr_draw->width : gr_draw->height); |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 49 | } |
| 50 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 51 | const GRFont* gr_sys_font() { |
| 52 | return gr_font; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 53 | } |
| 54 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 55 | int gr_measure(const GRFont* font, const char* s) { |
Tianjie Xu | 842f2a3 | 2018-05-31 18:16:28 -0700 | [diff] [blame] | 56 | if (font == nullptr) { |
| 57 | return -1; |
| 58 | } |
| 59 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 60 | return font->char_width * strlen(s); |
Damien Bargiacchi | 35fff61 | 2016-08-11 15:57:03 -0700 | [diff] [blame] | 61 | } |
| 62 | |
Tianjie Xu | 842f2a3 | 2018-05-31 18:16:28 -0700 | [diff] [blame] | 63 | int gr_font_size(const GRFont* font, int* x, int* y) { |
| 64 | if (font == nullptr) { |
| 65 | return -1; |
| 66 | } |
| 67 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 68 | *x = font->char_width; |
| 69 | *y = font->char_height; |
Tianjie Xu | 842f2a3 | 2018-05-31 18:16:28 -0700 | [diff] [blame] | 70 | return 0; |
Dima Zavin | 3c7f00e | 2011-08-30 11:58:24 -0700 | [diff] [blame] | 71 | } |
| 72 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 73 | // Blends gr_current onto pix value, assumes alpha as most significant byte. |
| 74 | static inline uint32_t pixel_blend(uint8_t alpha, uint32_t pix) { |
| 75 | if (alpha == 255) return gr_current; |
| 76 | if (alpha == 0) return pix; |
| 77 | uint32_t pix_r = pix & 0xff; |
| 78 | uint32_t pix_g = pix & 0xff00; |
| 79 | uint32_t pix_b = pix & 0xff0000; |
| 80 | uint32_t cur_r = gr_current & 0xff; |
| 81 | uint32_t cur_g = gr_current & 0xff00; |
| 82 | uint32_t cur_b = gr_current & 0xff0000; |
| 83 | |
| 84 | uint32_t out_r = (pix_r * (255 - alpha) + cur_r * alpha) / 255; |
| 85 | uint32_t out_g = (pix_g * (255 - alpha) + cur_g * alpha) / 255; |
| 86 | uint32_t out_b = (pix_b * (255 - alpha) + cur_b * alpha) / 255; |
| 87 | |
| 88 | return (out_r & 0xff) | (out_g & 0xff00) | (out_b & 0xff0000) | (gr_current & 0xff000000); |
| 89 | } |
| 90 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 91 | // Increments pixel pointer right, with current rotation. |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 92 | static void incr_x(uint32_t** p, int row_pixels) { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 93 | if (rotation == GRRotation::LEFT) { |
| 94 | *p = *p - row_pixels; |
| 95 | } else if (rotation == GRRotation::RIGHT) { |
| 96 | *p = *p + row_pixels; |
| 97 | } else if (rotation == GRRotation::DOWN) { |
| 98 | *p = *p - 1; |
| 99 | } else { // GRRotation::NONE |
| 100 | *p = *p + 1; |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 101 | } |
| 102 | } |
| 103 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 104 | // Increments pixel pointer down, with current rotation. |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 105 | static void incr_y(uint32_t** p, int row_pixels) { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 106 | if (rotation == GRRotation::LEFT) { |
| 107 | *p = *p + 1; |
| 108 | } else if (rotation == GRRotation::RIGHT) { |
| 109 | *p = *p - 1; |
| 110 | } else if (rotation == GRRotation::DOWN) { |
| 111 | *p = *p - row_pixels; |
| 112 | } else { // GRRotation::NONE |
| 113 | *p = *p + row_pixels; |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 114 | } |
| 115 | } |
| 116 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 117 | // Returns pixel pointer at given coordinates with rotation adjustment. |
| 118 | static uint32_t* pixel_at(const GRSurface* surf, int x, int y, int row_pixels) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 119 | switch (rotation) { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 120 | case GRRotation::NONE: |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 121 | return reinterpret_cast<uint32_t*>(surf->data) + y * row_pixels + x; |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 122 | case GRRotation::RIGHT: |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 123 | return reinterpret_cast<uint32_t*>(surf->data) + x * row_pixels + (surf->width - y); |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 124 | case GRRotation::DOWN: |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 125 | return reinterpret_cast<uint32_t*>(surf->data) + (surf->height - 1 - y) * row_pixels + |
| 126 | (surf->width - 1 - x); |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 127 | case GRRotation::LEFT: |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 128 | return reinterpret_cast<uint32_t*>(surf->data) + (surf->height - 1 - x) * row_pixels + y; |
| 129 | default: |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 130 | printf("invalid rotation %d", static_cast<int>(rotation)); |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 131 | } |
| 132 | return nullptr; |
| 133 | } |
| 134 | |
| 135 | static void text_blend(uint8_t* src_p, int src_row_bytes, uint32_t* dst_p, int dst_row_pixels, |
| 136 | int width, int height) { |
| 137 | uint8_t alpha_current = static_cast<uint8_t>((alpha_mask & gr_current) >> 24); |
| 138 | for (int j = 0; j < height; ++j) { |
| 139 | uint8_t* sx = src_p; |
| 140 | uint32_t* px = dst_p; |
| 141 | for (int i = 0; i < width; ++i, incr_x(&px, dst_row_pixels)) { |
| 142 | uint8_t a = *sx++; |
| 143 | if (alpha_current < 255) a = (static_cast<uint32_t>(a) * alpha_current) / 255; |
| 144 | *px = pixel_blend(a, *px); |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 145 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 146 | src_p += src_row_bytes; |
| 147 | incr_y(&dst_p, dst_row_pixels); |
| 148 | } |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 149 | } |
| 150 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 151 | void gr_text(const GRFont* font, int x, int y, const char* s, bool bold) { |
| 152 | if (!font || !font->texture || (gr_current & alpha_mask) == 0) return; |
Doug Zongker | 55a36ac | 2013-03-04 15:49:02 -0800 | [diff] [blame] | 153 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 154 | if (font->texture->pixel_bytes != 1) { |
| 155 | printf("gr_text: font has wrong format\n"); |
| 156 | return; |
| 157 | } |
Doug Zongker | 6fd59ac | 2013-03-06 15:01:11 -0800 | [diff] [blame] | 158 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 159 | bold = bold && (font->texture->height != font->char_height); |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 160 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 161 | x += overscan_offset_x; |
| 162 | y += overscan_offset_y; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 163 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 164 | unsigned char ch; |
| 165 | while ((ch = *s++)) { |
| 166 | if (outside(x, y) || outside(x + font->char_width - 1, y + font->char_height - 1)) break; |
Elliott Hughes | 01a4d08 | 2015-03-24 15:21:48 -0700 | [diff] [blame] | 167 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 168 | if (ch < ' ' || ch > '~') { |
| 169 | ch = '?'; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 170 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 171 | |
| 172 | int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes; |
| 173 | uint8_t* src_p = font->texture->data + ((ch - ' ') * font->char_width) + |
| 174 | (bold ? font->char_height * font->texture->row_bytes : 0); |
| 175 | uint32_t* dst_p = pixel_at(gr_draw, x, y, row_pixels); |
| 176 | |
| 177 | text_blend(src_p, font->texture->row_bytes, dst_p, row_pixels, font->char_width, |
| 178 | font->char_height); |
| 179 | |
| 180 | x += font->char_width; |
| 181 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 182 | } |
| 183 | |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 184 | void gr_texticon(int x, int y, GRSurface* icon) { |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 185 | if (icon == nullptr) return; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 186 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 187 | if (icon->pixel_bytes != 1) { |
| 188 | printf("gr_texticon: source has wrong format\n"); |
| 189 | return; |
| 190 | } |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 191 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 192 | x += overscan_offset_x; |
| 193 | y += overscan_offset_y; |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 194 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 195 | if (outside(x, y) || outside(x + icon->width - 1, y + icon->height - 1)) return; |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 196 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 197 | int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes; |
| 198 | uint8_t* src_p = icon->data; |
| 199 | uint32_t* dst_p = pixel_at(gr_draw, x, y, row_pixels); |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 200 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 201 | text_blend(src_p, icon->row_bytes, dst_p, row_pixels, icon->width, icon->height); |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 202 | } |
| 203 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 204 | void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { |
| 205 | uint32_t r32 = r, g32 = g, b32 = b, a32 = a; |
Tony Kuo | fd778e3 | 2015-02-05 21:25:56 +0800 | [diff] [blame] | 206 | #if defined(RECOVERY_ABGR) || defined(RECOVERY_BGRA) |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 207 | gr_current = (a32 << 24) | (r32 << 16) | (g32 << 8) | b32; |
Tony Kuo | fd778e3 | 2015-02-05 21:25:56 +0800 | [diff] [blame] | 208 | #else |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 209 | gr_current = (a32 << 24) | (b32 << 16) | (g32 << 8) | r32; |
Tony Kuo | fd778e3 | 2015-02-05 21:25:56 +0800 | [diff] [blame] | 210 | #endif |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 211 | } |
| 212 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 213 | void gr_clear() { |
| 214 | if ((gr_current & 0xff) == ((gr_current >> 8) & 0xff) && |
| 215 | (gr_current & 0xff) == ((gr_current >> 16) & 0xff) && |
| 216 | (gr_current & 0xff) == ((gr_current >> 24) & 0xff) && |
| 217 | gr_draw->row_bytes == gr_draw->width * gr_draw->pixel_bytes) { |
| 218 | memset(gr_draw->data, gr_current & 0xff, gr_draw->height * gr_draw->row_bytes); |
| 219 | } else { |
| 220 | uint32_t* px = reinterpret_cast<uint32_t*>(gr_draw->data); |
| 221 | int row_diff = gr_draw->row_bytes / gr_draw->pixel_bytes - gr_draw->width; |
| 222 | for (int y = 0; y < gr_draw->height; ++y) { |
| 223 | for (int x = 0; x < gr_draw->width; ++x) { |
| 224 | *px++ = gr_current; |
| 225 | } |
| 226 | px += row_diff; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 227 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 228 | } |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 229 | } |
| 230 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 231 | void gr_fill(int x1, int y1, int x2, int y2) { |
| 232 | x1 += overscan_offset_x; |
| 233 | y1 += overscan_offset_y; |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 234 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 235 | x2 += overscan_offset_x; |
| 236 | y2 += overscan_offset_y; |
Doug Zongker | c560a67 | 2012-12-18 16:31:27 -0800 | [diff] [blame] | 237 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 238 | if (outside(x1, y1) || outside(x2 - 1, y2 - 1)) return; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 239 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 240 | int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes; |
| 241 | uint32_t* p = pixel_at(gr_draw, x1, y1, row_pixels); |
| 242 | uint8_t alpha = static_cast<uint8_t>(((gr_current & alpha_mask) >> 24)); |
| 243 | if (alpha > 0) { |
| 244 | for (int y = y1; y < y2; ++y) { |
| 245 | uint32_t* px = p; |
| 246 | for (int x = x1; x < x2; ++x) { |
| 247 | *px = pixel_blend(alpha, *px); |
| 248 | incr_x(&px, row_pixels); |
| 249 | } |
| 250 | incr_y(&p, row_pixels); |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 251 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 252 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 253 | } |
| 254 | |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 255 | void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) { |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 256 | if (source == nullptr) return; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 257 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 258 | if (gr_draw->pixel_bytes != source->pixel_bytes) { |
| 259 | printf("gr_blit: source has wrong format\n"); |
| 260 | return; |
| 261 | } |
| 262 | |
| 263 | dx += overscan_offset_x; |
| 264 | dy += overscan_offset_y; |
| 265 | |
| 266 | if (outside(dx, dy) || outside(dx + w - 1, dy + h - 1)) return; |
| 267 | |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 268 | if (rotation != GRRotation::NONE) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 269 | int src_row_pixels = source->row_bytes / source->pixel_bytes; |
| 270 | int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes; |
| 271 | uint32_t* src_py = reinterpret_cast<uint32_t*>(source->data) + sy * source->row_bytes / 4 + sx; |
| 272 | uint32_t* dst_py = pixel_at(gr_draw, dx, dy, row_pixels); |
| 273 | |
| 274 | for (int y = 0; y < h; y += 1) { |
| 275 | uint32_t* src_px = src_py; |
| 276 | uint32_t* dst_px = dst_py; |
| 277 | for (int x = 0; x < w; x += 1) { |
| 278 | *dst_px = *src_px++; |
| 279 | incr_x(&dst_px, row_pixels); |
| 280 | } |
| 281 | src_py += src_row_pixels; |
| 282 | incr_y(&dst_py, row_pixels); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 283 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 284 | } else { |
| 285 | unsigned char* src_p = source->data + sy * source->row_bytes + sx * source->pixel_bytes; |
| 286 | unsigned char* dst_p = gr_draw->data + dy * gr_draw->row_bytes + dx * gr_draw->pixel_bytes; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 287 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 288 | for (int i = 0; i < h; ++i) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 289 | memcpy(dst_p, src_p, w * source->pixel_bytes); |
| 290 | src_p += source->row_bytes; |
| 291 | dst_p += gr_draw->row_bytes; |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 292 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 293 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 294 | } |
| 295 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 296 | unsigned int gr_get_width(const GRSurface* surface) { |
| 297 | if (surface == nullptr) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 298 | return 0; |
| 299 | } |
| 300 | return surface->width; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 301 | } |
| 302 | |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 303 | unsigned int gr_get_height(const GRSurface* surface) { |
| 304 | if (surface == nullptr) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 305 | return 0; |
| 306 | } |
| 307 | return surface->height; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 308 | } |
| 309 | |
Damien Bargiacchi | d00f5eb | 2016-09-09 07:14:08 -0700 | [diff] [blame] | 310 | int gr_init_font(const char* name, GRFont** dest) { |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 311 | GRFont* font = static_cast<GRFont*>(calloc(1, sizeof(*gr_font))); |
| 312 | if (font == nullptr) { |
| 313 | return -1; |
| 314 | } |
Damien Bargiacchi | d00f5eb | 2016-09-09 07:14:08 -0700 | [diff] [blame] | 315 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 316 | int res = res_create_alpha_surface(name, &(font->texture)); |
| 317 | if (res < 0) { |
| 318 | free(font); |
| 319 | return res; |
| 320 | } |
Damien Bargiacchi | 35fff61 | 2016-08-11 15:57:03 -0700 | [diff] [blame] | 321 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 322 | // The font image should be a 96x2 array of character images. The |
| 323 | // columns are the printable ASCII characters 0x20 - 0x7f. The |
| 324 | // top row is regular text; the bottom row is bold. |
| 325 | font->char_width = font->texture->width / 96; |
| 326 | font->char_height = font->texture->height / 2; |
Damien Bargiacchi | d00f5eb | 2016-09-09 07:14:08 -0700 | [diff] [blame] | 327 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 328 | *dest = font; |
Damien Bargiacchi | 35fff61 | 2016-08-11 15:57:03 -0700 | [diff] [blame] | 329 | |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 330 | return 0; |
Damien Bargiacchi | 35fff61 | 2016-08-11 15:57:03 -0700 | [diff] [blame] | 331 | } |
| 332 | |
Doug Zongker | 5290f20 | 2014-03-11 13:22:04 -0700 | [diff] [blame] | 333 | void gr_flip() { |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 334 | gr_draw = gr_backend->Flip(); |
Doug Zongker | 5290f20 | 2014-03-11 13:22:04 -0700 | [diff] [blame] | 335 | } |
| 336 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 337 | int gr_init() { |
Tianjie Xu | 55a2c4e | 2018-03-29 11:07:50 -0700 | [diff] [blame] | 338 | int ret = gr_init_font("font", &gr_font); |
| 339 | if (ret != 0) { |
Tianjie Xu | 842f2a3 | 2018-05-31 18:16:28 -0700 | [diff] [blame] | 340 | printf("Failed to init font: %d, continuing graphic backend initialization without font file\n", |
| 341 | ret); |
Tianjie Xu | 55a2c4e | 2018-03-29 11:07:50 -0700 | [diff] [blame] | 342 | } |
Doug Zongker | 16f97c3 | 2014-03-06 16:16:05 -0800 | [diff] [blame] | 343 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 344 | auto backend = std::unique_ptr<MinuiBackend>{ std::make_unique<MinuiBackendAdf>() }; |
| 345 | gr_draw = backend->Init(); |
Greg Hackmann | 41909dd | 2014-04-25 10:39:50 -0700 | [diff] [blame] | 346 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 347 | if (!gr_draw) { |
| 348 | backend = std::make_unique<MinuiBackendDrm>(); |
| 349 | gr_draw = backend->Init(); |
| 350 | } |
Stéphane Marchesin | 1a92c44 | 2015-06-29 20:05:48 -0700 | [diff] [blame] | 351 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 352 | if (!gr_draw) { |
| 353 | backend = std::make_unique<MinuiBackendFbdev>(); |
| 354 | gr_draw = backend->Init(); |
| 355 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 356 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 357 | if (!gr_draw) { |
| 358 | return -1; |
| 359 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 360 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 361 | gr_backend = backend.release(); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 362 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 363 | overscan_offset_x = gr_draw->width * overscan_percent / 100; |
| 364 | overscan_offset_y = gr_draw->height * overscan_percent / 100; |
| 365 | |
| 366 | gr_flip(); |
| 367 | gr_flip(); |
Tianjie Xu | ccf00a2 | 2018-06-05 17:10:23 -0700 | [diff] [blame] | 368 | if (!gr_draw) { |
| 369 | printf("gr_init: gr_draw becomes nullptr after gr_flip\n"); |
| 370 | return -1; |
| 371 | } |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 372 | |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 373 | #define __STRINGIFY(x) #x |
| 374 | #define STRINGIFY(x) __STRINGIFY(x) |
| 375 | |
| 376 | std::string rotation_str(STRINGIFY(DEFAULT_ROTATION)); |
| 377 | if (rotation_str == "ROTATION_RIGHT") { |
| 378 | gr_rotate(GRRotation::RIGHT); |
| 379 | } else if (rotation_str == "ROTATION_DOWN") { |
| 380 | gr_rotate(GRRotation::DOWN); |
| 381 | } else if (rotation_str == "ROTATION_LEFT") { |
| 382 | gr_rotate(GRRotation::LEFT); |
| 383 | } else { // "ROTATION_NONE" |
| 384 | gr_rotate(GRRotation::NONE); |
| 385 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 386 | |
| 387 | if (gr_draw->pixel_bytes != 4) { |
| 388 | printf("gr_init: Only 4-byte pixel formats supported\n"); |
| 389 | } |
| 390 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 391 | return 0; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 392 | } |
| 393 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 394 | void gr_exit() { |
| 395 | delete gr_backend; |
Tao Bao | 9f42633 | 2018-06-13 10:39:44 -0700 | [diff] [blame] | 396 | gr_backend = nullptr; |
| 397 | |
| 398 | delete gr_font; |
| 399 | gr_font = nullptr; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 400 | } |
| 401 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 402 | int gr_fb_width() { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 403 | return (rotation == GRRotation::LEFT || rotation == GRRotation::RIGHT) |
| 404 | ? gr_draw->height - 2 * overscan_offset_y |
| 405 | : gr_draw->width - 2 * overscan_offset_x; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 406 | } |
| 407 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 408 | int gr_fb_height() { |
Tao Bao | 44478df | 2018-07-31 22:01:03 -0700 | [diff] [blame] | 409 | return (rotation == GRRotation::LEFT || rotation == GRRotation::RIGHT) |
| 410 | ? gr_draw->width - 2 * overscan_offset_x |
| 411 | : gr_draw->height - 2 * overscan_offset_y; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 412 | } |
Dima Zavin | 4daf48a | 2011-08-30 11:59:20 -0700 | [diff] [blame] | 413 | |
Tao Bao | 557fa1f | 2017-02-07 12:51:00 -0800 | [diff] [blame] | 414 | void gr_fb_blank(bool blank) { |
| 415 | gr_backend->Blank(blank); |
Dima Zavin | 4daf48a | 2011-08-30 11:59:20 -0700 | [diff] [blame] | 416 | } |
Luke Song | 846012f | 2017-09-13 15:56:16 -0700 | [diff] [blame] | 417 | |
| 418 | void gr_rotate(GRRotation rot) { |
| 419 | rotation = rot; |
| 420 | } |