Merge "minui: Move GRSurface into a class." (66a576b7) · Commits · e / os / android_bootable_recovery

minui/graphics.cpp

+30 −29

Original line number	Diff line number	Diff line
		@@ -40,7 +40,7 @@ static uint32_t gr_current = ~0;
		static constexpr uint32_t alpha_mask = 0xff000000;

		// gr_draw is owned by backends.
		static const GRSurface* gr_draw = nullptr;
		static GRSurface* gr_draw = nullptr;
		static GRRotation rotation = GRRotation::NONE;
		static PixelFormat pixel_format = PixelFormat::UNKNOWN;

		@@ -121,28 +121,29 @@ static void incr_y(uint32_t** p, int row_pixels) {
		}

		// Returns pixel pointer at given coordinates with rotation adjustment.
		static uint32_t* pixel_at(const GRSurface* surf, int x, int y, int row_pixels) {
		static uint32_t* PixelAt(GRSurface* surface, int x, int y, int row_pixels) {
		switch (rotation) {
		case GRRotation::NONE:
		return reinterpret_cast<uint32_t>(surf->data) + y row_pixels + x;
		return reinterpret_cast<uint32_t>(surface->data()) + y row_pixels + x;
		case GRRotation::RIGHT:
		return reinterpret_cast<uint32_t>(surf->data) + x row_pixels + (surf->width - y);
		return reinterpret_cast<uint32_t>(surface->data()) + x row_pixels + (surface->width - y);
		case GRRotation::DOWN:
		return reinterpret_cast<uint32_t>(surf->data) + (surf->height - 1 - y) row_pixels +
		(surf->width - 1 - x);
		return reinterpret_cast<uint32_t>(surface->data()) + (surface->height - 1 - y) row_pixels +
		(surface->width - 1 - x);
		case GRRotation::LEFT:
		return reinterpret_cast<uint32_t>(surf->data) + (surf->height - 1 - x) row_pixels + y;
		return reinterpret_cast<uint32_t>(surface->data()) + (surface->height - 1 - x) row_pixels +
		y;
		default:
		printf("invalid rotation %d", static_cast<int>(rotation));
		}
		return nullptr;
		}

		static void text_blend(uint8_t* src_p, int src_row_bytes, uint32_t* dst_p, int dst_row_pixels,
		static void TextBlend(const uint8_t* src_p, int src_row_bytes, uint32_t* dst_p, int dst_row_pixels,
		int width, int height) {
		uint8_t alpha_current = static_cast<uint8_t>((alpha_mask & gr_current) >> 24);
		for (int j = 0; j < height; ++j) {
		uint8_t* sx = src_p;
		const uint8_t* sx = src_p;
		uint32_t* px = dst_p;
		for (int i = 0; i < width; ++i, incr_x(&px, dst_row_pixels)) {
		uint8_t a = *sx++;
		@@ -176,18 +177,18 @@ void gr_text(const GRFont* font, int x, int y, const char* s, bool bold) {
		}

		int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes;
		uint8_t* src_p = font->texture->data + ((ch - ' ') * font->char_width) +
		const uint8_t* src_p = font->texture->data() + ((ch - ' ') * font->char_width) +
		(bold ? font->char_height * font->texture->row_bytes : 0);
		uint32_t* dst_p = pixel_at(gr_draw, x, y, row_pixels);
		uint32_t* dst_p = PixelAt(gr_draw, x, y, row_pixels);

		text_blend(src_p, font->texture->row_bytes, dst_p, row_pixels, font->char_width,
		TextBlend(src_p, font->texture->row_bytes, dst_p, row_pixels, font->char_width,
		font->char_height);

		x += font->char_width;
		}
		}

		void gr_texticon(int x, int y, GRSurface* icon) {
		void gr_texticon(int x, int y, const GRSurface* icon) {
		if (icon == nullptr) return;

		if (icon->pixel_bytes != 1) {
		@@ -201,10 +202,9 @@ void gr_texticon(int x, int y, GRSurface* icon) {
		if (outside(x, y) \|\| outside(x + icon->width - 1, y + icon->height - 1)) return;

		int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes;
		uint8_t* src_p = icon->data;
		uint32_t* dst_p = pixel_at(gr_draw, x, y, row_pixels);

		text_blend(src_p, icon->row_bytes, dst_p, row_pixels, icon->width, icon->height);
		const uint8_t* src_p = icon->data();
		uint32_t* dst_p = PixelAt(gr_draw, x, y, row_pixels);
		TextBlend(src_p, icon->row_bytes, dst_p, row_pixels, icon->width, icon->height);
		}

		void gr_color(unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
		@@ -221,9 +221,9 @@ void gr_clear() {
		(gr_current & 0xff) == ((gr_current >> 16) & 0xff) &&
		(gr_current & 0xff) == ((gr_current >> 24) & 0xff) &&
		gr_draw->row_bytes == gr_draw->width * gr_draw->pixel_bytes) {
		memset(gr_draw->data, gr_current & 0xff, gr_draw->height * gr_draw->row_bytes);
		memset(gr_draw->data(), gr_current & 0xff, gr_draw->height * gr_draw->row_bytes);
		} else {
		uint32_t* px = reinterpret_cast<uint32_t*>(gr_draw->data);
		uint32_t* px = reinterpret_cast<uint32_t*>(gr_draw->data());
		int row_diff = gr_draw->row_bytes / gr_draw->pixel_bytes - gr_draw->width;
		for (int y = 0; y < gr_draw->height; ++y) {
		for (int x = 0; x < gr_draw->width; ++x) {
		@@ -244,7 +244,7 @@ void gr_fill(int x1, int y1, int x2, int y2) {
		if (outside(x1, y1) \|\| outside(x2 - 1, y2 - 1)) return;

		int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes;
		uint32_t* p = pixel_at(gr_draw, x1, y1, row_pixels);
		uint32_t* p = PixelAt(gr_draw, x1, y1, row_pixels);
		uint8_t alpha = static_cast<uint8_t>(((gr_current & alpha_mask) >> 24));
		if (alpha > 0) {
		for (int y = y1; y < y2; ++y) {
		@@ -258,7 +258,7 @@ void gr_fill(int x1, int y1, int x2, int y2) {
		}
		}

		void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
		void gr_blit(const GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
		if (source == nullptr) return;

		if (gr_draw->pixel_bytes != source->pixel_bytes) {
		@@ -274,11 +274,12 @@ void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
		if (rotation != GRRotation::NONE) {
		int src_row_pixels = source->row_bytes / source->pixel_bytes;
		int row_pixels = gr_draw->row_bytes / gr_draw->pixel_bytes;
		uint32_t* src_py = reinterpret_cast<uint32_t>(source->data) + sy source->row_bytes / 4 + sx;
		uint32_t* dst_py = pixel_at(gr_draw, dx, dy, row_pixels);
		const uint32_t* src_py =
		reinterpret_cast<const uint32_t>(source->data()) + sy source->row_bytes / 4 + sx;
		uint32_t* dst_py = PixelAt(gr_draw, dx, dy, row_pixels);

		for (int y = 0; y < h; y += 1) {
		uint32_t* src_px = src_py;
		const uint32_t* src_px = src_py;
		uint32_t* dst_px = dst_py;
		for (int x = 0; x < w; x += 1) {
		dst_px = src_px++;
		@@ -288,8 +289,8 @@ void gr_blit(GRSurface* source, int sx, int sy, int w, int h, int dx, int dy) {
		incr_y(&dst_py, row_pixels);
		}
		} else {
		unsigned char* src_p = source->data + sy * source->row_bytes + sx * source->pixel_bytes;
		unsigned char* dst_p = gr_draw->data + dy * gr_draw->row_bytes + dx * gr_draw->pixel_bytes;
		const uint8_t* src_p = source->data() + sy * source->row_bytes + sx * source->pixel_bytes;
		uint8_t* dst_p = gr_draw->data() + dy * gr_draw->row_bytes + dx * gr_draw->pixel_bytes;

		for (int i = 0; i < h; ++i) {
		memcpy(dst_p, src_p, w * source->pixel_bytes);

minui/graphics_adf.cpp

+7 −5

Original line number	Diff line number	Diff line
		@@ -45,14 +45,14 @@ int MinuiBackendAdf::SurfaceInit(const drm_mode_modeinfo* mode, GRSurfaceAdf* su
		surf->row_bytes = surf->pitch;
		surf->pixel_bytes = (format == DRM_FORMAT_RGB565) ? 2 : 4;

		surf->data = static_cast<uint8_t*>(
		mmap(nullptr, surf->pitch * surf->height, PROT_WRITE, MAP_SHARED, surf->fd, surf->offset));
		if (surf->data == MAP_FAILED) {
		auto mmapped =
		mmap(nullptr, surf->pitch * surf->height, PROT_WRITE, MAP_SHARED, surf->fd, surf->offset);
		if (mmapped == MAP_FAILED) {
		int saved_errno = errno;
		close(surf->fd);
		return -saved_errno;
		}

		surf->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);
		return 0;
		}

		@@ -185,7 +185,9 @@ void MinuiBackendAdf::Blank(bool blank) {
		}

		void MinuiBackendAdf::SurfaceDestroy(GRSurfaceAdf* surf) {
		munmap(surf->data, surf->pitch * surf->height);
		if (surf->mmapped_buffer_) {
		munmap(surf->mmapped_buffer_, surf->pitch * surf->height);
		}
		close(surf->fence_fd);
		close(surf->fd);
		}

minui/graphics_adf.h

+12 −5

Original line number	Diff line number	Diff line
		@@ -14,21 +14,30 @@
		* limitations under the License.
		*/

		#ifndef _GRAPHICS_ADF_H_
		#define _GRAPHICS_ADF_H_
		#pragma once

		#include <stdint.h>

		#include <adf/adf.h>

		#include "graphics.h"
		#include "minui/minui.h"

		class GRSurfaceAdf : public GRSurface {
		public:
		uint8_t* data() override {
		return mmapped_buffer_;
		}

		private:
		friend class MinuiBackendAdf;

		int fence_fd;
		int fd;
		__u32 offset;
		__u32 pitch;

		friend class MinuiBackendAdf;
		uint8_t* mmapped_buffer_{ nullptr };
		};

		class MinuiBackendAdf : public MinuiBackend {
		@@ -54,5 +63,3 @@ class MinuiBackendAdf : public MinuiBackend {
		unsigned int n_surfaces;
		GRSurfaceAdf surfaces[2];
		};

		#endif // _GRAPHICS_ADF_H_

minui/graphics_drm.cpp

+6 −7

Original line number	Diff line number	Diff line
		@@ -70,8 +70,8 @@ void MinuiBackendDrm::Blank(bool blank) {
		void MinuiBackendDrm::DrmDestroySurface(GRSurfaceDrm* surface) {
		if (!surface) return;

		if (surface->data) {
		munmap(surface->data, surface->row_bytes * surface->height);
		if (surface->mmapped_buffer_) {
		munmap(surface->mmapped_buffer_, surface->row_bytes * surface->height);
		}

		if (surface->fb_id) {
		@@ -172,15 +172,14 @@ GRSurfaceDrm* MinuiBackendDrm::DrmCreateSurface(int width, int height) {
		surface->width = width;
		surface->row_bytes = create_dumb.pitch;
		surface->pixel_bytes = create_dumb.bpp / 8;
		surface->data = static_cast<unsigned char>(mmap(nullptr, surface->height surface->row_bytes,
		PROT_READ \| PROT_WRITE, MAP_SHARED, drm_fd,
		map_dumb.offset));
		if (surface->data == MAP_FAILED) {
		auto mmapped = mmap(nullptr, surface->height * surface->row_bytes, PROT_READ \| PROT_WRITE,
		MAP_SHARED, drm_fd, map_dumb.offset);
		if (mmapped == MAP_FAILED) {
		perror("mmap() failed");
		DrmDestroySurface(surface);
		return nullptr;
		}

		surface->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);
		return surface;
		}

minui/graphics_drm.h

+9 −6

Original line number	Diff line number	Diff line
		@@ -14,8 +14,7 @@
		* limitations under the License.
		*/

		#ifndef _GRAPHICS_DRM_H_
		#define _GRAPHICS_DRM_H_
		#pragma once

		#include <stdint.h>

		@@ -25,11 +24,17 @@
		#include "minui/minui.h"

		class GRSurfaceDrm : public GRSurface {
		public:
		uint8_t* data() override {
		return mmapped_buffer_;
		}

		private:
		friend class MinuiBackendDrm;

		uint32_t fb_id;
		uint32_t handle;

		friend class MinuiBackendDrm;
		uint8_t* mmapped_buffer_{ nullptr };
		};

		class MinuiBackendDrm : public MinuiBackend {
		@@ -54,5 +59,3 @@ class MinuiBackendDrm : public MinuiBackend {
		drmModeConnector* main_monitor_connector;
		int drm_fd;
		};

		#endif // _GRAPHICS_DRM_H_