Vladimir Oltean
d32b7ebf20
* The existence of TW_ROTATION that implements this feature at the
level of calls to libpixelflinger API closely mirrors the existence of
ro.sf.hwrotation for surfaceflinger in LineageOS.
* A brute-force approach was previously attempted via the
BOARD_HAS_FLIPPED_SCREEN makefile flag. That code iterated over the
active display surface in a double-buffered setup, and performed a
"smart" memcpy from the UI drawing surface (gr_draw) onto the display
surface. The problem was that, without heavy loop optimizations, that
code could have never scaled for 90 and 270 degree rotation.
I tried and you could literally see the for loop with the naked eye
while the display surface was updating.
* That code is now gone, but support for BOARD_HAS_FLIPPED_SCREEN := true
is still there (now means TW_ROTATION := 180).
* This patch relies on the assumption that it is impossibly difficult
and non-portable to rotate whole framebuffer display surfaces, in a
way that is not dependent upon the graphics backend (adf, fbdev, drm,
overlay etc). Therefore, it identifies the rendering primitives that
the TWRP graphics stack exposes to the GUI application above, and
implements hwrotation inside each of those calls instead:
- gr_line(), gr_fill() - 2D geometric shapes (lines, rectangles)
- gr_blit() - graphical image resources
- gr_ttf_textExWH() - font rendering
- gr_fb_width(), gr_fb_height() - framebuffer resolution
* The gist is to keep the backend and framebuffer (dimensions, row size
etc) unchanged (because making changes there is asking for trouble),
but present an altogether different reality to the calling API,
according to the compile-time constant TW_ROTATION.
* All (x, y) API coordinates and shapes are transformed before being
actually rendered as (x_disp, y_disp) display coordinates.
* With TW_ROTATION := 90 or 270 you can turn a landscape device into
a portrait one, because the GUI is fooled by the reversed dimensions
reported by gr_fb_width() and gr_fb_height() and renders the UI as
for a different device.
* For blit and text rendering operations, figuring out the transformed
coordinates in display space is not enough, as the surfaces that are
to be rendered have to be rotated themselves. This is handled by
allocating an intermediary rotated surface on each rendering
operation (not ideal), so the code with the intermediary surface
is compiled out for the TW_ROTATION := 0 case.
* This is still not as bad as rotating the whole framebuffer though, and
on a msm8976 device the performance hit is not even noticeable (for
software rendering).
* Currently there is no attempt to make a connection between the
TW_ROTATION and the { RECOVERY_TOUCHSCREEN_SWAP_XY,
RECOVERY_TOUCHSCREEN_FLIP_X, RECOVERY_TOUCHSCREEN_FLIP_Y } settings.
Change-Id: Ic8966ad5360c8a499649fdb16e242286640fd992
Signed-off-by: Vladimir Oltean <olteanv@gmail.com>
111 lines
3.7 KiB
C
111 lines
3.7 KiB
C
/*
|
|
* Copyright (C) 2007 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef _MINUI_H_
|
|
#define _MINUI_H_
|
|
|
|
#include "../gui/placement.h"
|
|
#include <stdbool.h>
|
|
|
|
struct GRSurface {
|
|
int width;
|
|
int height;
|
|
int row_bytes;
|
|
int pixel_bytes;
|
|
unsigned char* data;
|
|
__u32 format;
|
|
};
|
|
|
|
typedef void* gr_surface;
|
|
typedef unsigned short gr_pixel;
|
|
|
|
#define FONT_TYPE_TWRP 0
|
|
#define FONT_TYPE_TTF 1
|
|
|
|
int gr_init(void);
|
|
void gr_exit(void);
|
|
|
|
int gr_fb_width(void);
|
|
int gr_fb_height(void);
|
|
gr_pixel *gr_fb_data(void);
|
|
void gr_flip(void);
|
|
void gr_fb_blank(bool blank);
|
|
|
|
void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a);
|
|
void gr_clip(int x, int y, int w, int h);
|
|
void gr_noclip();
|
|
void gr_fill(int x, int y, int w, int h);
|
|
void gr_line(int x0, int y0, int x1, int y1, int width);
|
|
gr_surface gr_render_circle(int radius, unsigned char r, unsigned char g, unsigned char b, unsigned char a);
|
|
|
|
int gr_textEx_scaleW(int x, int y, const char *s, void* pFont, int max_width, int placement, int scale);
|
|
|
|
int gr_getMaxFontHeight(void *font);
|
|
|
|
void *gr_ttf_loadFont(const char *filename, int size, int dpi);
|
|
void *gr_ttf_scaleFont(void *font, int max_width, int measured_width);
|
|
void gr_ttf_freeFont(void *font);
|
|
int gr_ttf_textExWH(void *context, int x, int y, const char *s, void *pFont,
|
|
int max_width, int max_height, const gr_surface gr_draw);
|
|
int gr_ttf_measureEx(const char *s, void *font);
|
|
int gr_ttf_maxExW(const char *s, void *font, int max_width);
|
|
int gr_ttf_getMaxFontHeight(void *font);
|
|
void gr_ttf_dump_stats(void);
|
|
|
|
void gr_blit(gr_surface source, int sx, int sy, int w, int h, int dx, int dy);
|
|
unsigned int gr_get_width(gr_surface surface);
|
|
unsigned int gr_get_height(gr_surface surface);
|
|
int gr_get_surface(gr_surface* surface);
|
|
int gr_free_surface(gr_surface surface);
|
|
|
|
// Functions in graphics_utils.c
|
|
int gr_save_screenshot(const char *dest);
|
|
|
|
// Transform minuitwrp API coordinates into display coordinates,
|
|
// for panels that are hardware-mounted in a rotated manner.
|
|
#define ROTATION_X_DISP(x, y, surface) \
|
|
((TW_ROTATION == 0) ? (x) : \
|
|
(TW_ROTATION == 90) ? ((surface)->width - (y) - 1) : \
|
|
(TW_ROTATION == 180) ? ((surface)->width - (x) - 1) : \
|
|
(TW_ROTATION == 270) ? (y) : -1)
|
|
#define ROTATION_Y_DISP(x, y, surface) \
|
|
((TW_ROTATION == 0) ? (y) : \
|
|
(TW_ROTATION == 90) ? (x) : \
|
|
(TW_ROTATION == 180) ? ((surface)->height - (y) - 1) : \
|
|
(TW_ROTATION == 270) ? ((surface)->height - (x) - 1) : -1)
|
|
|
|
void surface_ROTATION_transform(gr_surface dst_ptr, const gr_surface src_ptr, size_t num_bytes_per_pixel);
|
|
|
|
// input event structure, include <linux/input.h> for the definition.
|
|
// see http://www.mjmwired.net/kernel/Documentation/input/ for info.
|
|
struct input_event;
|
|
|
|
int ev_init(void);
|
|
void ev_exit(void);
|
|
int ev_get(struct input_event *ev, int timeout_ms);
|
|
int ev_has_mouse(void);
|
|
|
|
// Resources
|
|
|
|
// Returns 0 if no error, else negative.
|
|
int res_create_surface(const char* name, gr_surface* pSurface);
|
|
void res_free_surface(gr_surface surface);
|
|
int res_scale_surface(gr_surface source, gr_surface* destination, float scale_w, float scale_h);
|
|
|
|
int vibrate(int timeout_ms);
|
|
|
|
#endif
|