mirror of
https://github.com/bytecodealliance/wasm-micro-runtime.git
synced 2024-10-05 07:32:07 +00:00
304 lines
7.7 KiB
C
304 lines
7.7 KiB
C
/*
|
|
* Copyright (C) 2019 Intel Corporation. All rights reserved.
|
|
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include "display_indev.h"
|
|
#include "sys/time.h"
|
|
#include "SDL2/SDL.h"
|
|
#define MONITOR_HOR_RES 320
|
|
#define MONITOR_VER_RES 240
|
|
#ifndef MONITOR_ZOOM
|
|
#define MONITOR_ZOOM 1
|
|
#endif
|
|
#define SDL_REFR_PERIOD 50
|
|
void monitor_sdl_init(void);
|
|
void monitor_sdl_refr_core(void);
|
|
void monitor_sdl_clean_up(void);
|
|
static uint32_t tft_fb[MONITOR_HOR_RES * MONITOR_VER_RES];
|
|
|
|
void display_vdb_write(void *buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
|
|
lv_color_t *color, lv_opa_t opa)
|
|
{
|
|
unsigned char *buf_xy = buf + 4 * x + 4 * y * buf_w;
|
|
lv_color_t * temp = (lv_color_t *) buf_xy;
|
|
*temp = *color;
|
|
/*
|
|
if (opa != LV_OPA_COVER) {
|
|
lv_color_t mix_color;
|
|
|
|
mix_color.red = *buf_xy;
|
|
mix_color.green = *(buf_xy+1);
|
|
mix_color.blue = *(buf_xy+2);
|
|
color = lv_color_mix(color, mix_color, opa);
|
|
}
|
|
*/
|
|
}
|
|
int time_get_ms()
|
|
{
|
|
static struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
long long time_in_mill = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
|
|
|
|
return (int) time_in_mill;
|
|
}
|
|
|
|
SDL_Window * window;
|
|
SDL_Renderer * renderer;
|
|
SDL_Texture * texture;
|
|
static volatile bool sdl_inited = false;
|
|
static volatile bool sdl_refr_qry = false;
|
|
static volatile bool sdl_quit_qry = false;
|
|
|
|
void monitor_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
const lv_color_t * color_p)
|
|
{
|
|
/*Return if the area is out the screen*/
|
|
if (x2 < 0 || y2 < 0 || x1 > MONITOR_HOR_RES - 1
|
|
|| y1 > MONITOR_VER_RES - 1) {
|
|
return;
|
|
}
|
|
|
|
int32_t y;
|
|
uint32_t w = x2 - x1 + 1;
|
|
for (y = y1; y <= y2; y++) {
|
|
memcpy(&tft_fb[y * MONITOR_HOR_RES + x1], color_p,
|
|
w * sizeof(lv_color_t));
|
|
|
|
color_p += w;
|
|
}
|
|
sdl_refr_qry = true;
|
|
|
|
/*IMPORTANT! It must be called to tell the system the flush is ready*/
|
|
|
|
}
|
|
|
|
/**
|
|
* Fill out the marked area with a color
|
|
* @param x1 left coordinate
|
|
* @param y1 top coordinate
|
|
* @param x2 right coordinate
|
|
* @param y2 bottom coordinate
|
|
* @param color fill color
|
|
*/
|
|
void monitor_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
lv_color_t color)
|
|
{
|
|
/*Return if the area is out the screen*/
|
|
if (x2 < 0)
|
|
return;
|
|
if (y2 < 0)
|
|
return;
|
|
if (x1 > MONITOR_HOR_RES - 1)
|
|
return;
|
|
if (y1 > MONITOR_VER_RES - 1)
|
|
return;
|
|
|
|
/*Truncate the area to the screen*/
|
|
int32_t act_x1 = x1 < 0 ? 0 : x1;
|
|
int32_t act_y1 = y1 < 0 ? 0 : y1;
|
|
int32_t act_x2 = x2 > MONITOR_HOR_RES - 1 ? MONITOR_HOR_RES - 1 : x2;
|
|
int32_t act_y2 = y2 > MONITOR_VER_RES - 1 ? MONITOR_VER_RES - 1 : y2;
|
|
|
|
int32_t x;
|
|
int32_t y;
|
|
uint32_t color32 = color.full; //lv_color_to32(color);
|
|
|
|
for (x = act_x1; x <= act_x2; x++) {
|
|
for (y = act_y1; y <= act_y2; y++) {
|
|
tft_fb[y * MONITOR_HOR_RES + x] = color32;
|
|
}
|
|
}
|
|
|
|
sdl_refr_qry = true;
|
|
}
|
|
|
|
/**
|
|
* Put a color map to the marked area
|
|
* @param x1 left coordinate
|
|
* @param y1 top coordinate
|
|
* @param x2 right coordinate
|
|
* @param y2 bottom coordinate
|
|
* @param color_p an array of colors
|
|
*/
|
|
void monitor_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
const lv_color_t * color_p)
|
|
{
|
|
/*Return if the area is out the screen*/
|
|
if (x2 < 0)
|
|
return;
|
|
if (y2 < 0)
|
|
return;
|
|
if (x1 > MONITOR_HOR_RES - 1)
|
|
return;
|
|
if (y1 > MONITOR_VER_RES - 1)
|
|
return;
|
|
|
|
/*Truncate the area to the screen*/
|
|
int32_t act_x1 = x1 < 0 ? 0 : x1;
|
|
int32_t act_y1 = y1 < 0 ? 0 : y1;
|
|
int32_t act_x2 = x2 > MONITOR_HOR_RES - 1 ? MONITOR_HOR_RES - 1 : x2;
|
|
int32_t act_y2 = y2 > MONITOR_VER_RES - 1 ? MONITOR_VER_RES - 1 : y2;
|
|
|
|
int32_t x;
|
|
int32_t y;
|
|
|
|
for (y = act_y1; y <= act_y2; y++) {
|
|
for (x = act_x1; x <= act_x2; x++) {
|
|
tft_fb[y * MONITOR_HOR_RES + x] = color_p->full; //lv_color_to32(*color_p);
|
|
color_p++;
|
|
}
|
|
|
|
color_p += x2 - act_x2;
|
|
}
|
|
|
|
sdl_refr_qry = true;
|
|
}
|
|
|
|
void display_init(void)
|
|
{
|
|
}
|
|
|
|
void display_flush(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
const lv_color_t * color_p)
|
|
{
|
|
monitor_flush(x1, y1, x2, y2, color_p);
|
|
}
|
|
void display_fill(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
lv_color_t color_p)
|
|
{
|
|
monitor_fill(x1, y1, x2, y2, color_p);
|
|
}
|
|
void display_map(int32_t x1, int32_t y1, int32_t x2, int32_t y2,
|
|
const lv_color_t * color_p)
|
|
{
|
|
monitor_map(x1, y1, x2, y2, color_p);
|
|
}
|
|
|
|
bool display_input_read(lv_indev_data_t * data)
|
|
{
|
|
return mouse_read(data);
|
|
}
|
|
|
|
void display_deinit(void)
|
|
{
|
|
|
|
}
|
|
|
|
int monitor_sdl_refr_thread(void * param)
|
|
{
|
|
(void) param;
|
|
|
|
/*If not OSX initialize SDL in the Thread*/
|
|
monitor_sdl_init();
|
|
/*Run until quit event not arrives*/
|
|
while (sdl_quit_qry == false) {
|
|
/*Refresh handling*/
|
|
monitor_sdl_refr_core();
|
|
}
|
|
|
|
monitor_sdl_clean_up();
|
|
exit(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void monitor_sdl_refr_core(void)
|
|
{
|
|
if (sdl_refr_qry != false) {
|
|
sdl_refr_qry = false;
|
|
|
|
SDL_UpdateTexture(texture, NULL, tft_fb,
|
|
MONITOR_HOR_RES * sizeof(uint32_t));
|
|
SDL_RenderClear(renderer);
|
|
/*Test: Draw a background to test transparent screens (LV_COLOR_SCREEN_TRANSP)*/
|
|
// SDL_SetRenderDrawColor(renderer, 0xff, 0, 0, 0xff);
|
|
// SDL_Rect r;
|
|
// r.x = 0; r.y = 0; r.w = MONITOR_HOR_RES; r.w = MONITOR_VER_RES;
|
|
// SDL_RenderDrawRect(renderer, &r);
|
|
/*Update the renderer with the texture containing the rendered image*/
|
|
SDL_RenderCopy(renderer, texture, NULL, NULL);
|
|
SDL_RenderPresent(renderer);
|
|
}
|
|
|
|
SDL_Event event;
|
|
while (SDL_PollEvent(&event)) {
|
|
#if USE_MOUSE != 0
|
|
mouse_handler(&event);
|
|
#endif
|
|
if ((&event)->type == SDL_WINDOWEVENT) {
|
|
switch ((&event)->window.event) {
|
|
#if SDL_VERSION_ATLEAST(2, 0, 5)
|
|
case SDL_WINDOWEVENT_TAKE_FOCUS:
|
|
#endif
|
|
case SDL_WINDOWEVENT_EXPOSED:
|
|
|
|
SDL_UpdateTexture(texture, NULL, tft_fb,
|
|
MONITOR_HOR_RES * sizeof(uint32_t));
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderCopy(renderer, texture, NULL, NULL);
|
|
SDL_RenderPresent(renderer);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*Sleep some time*/
|
|
SDL_Delay(SDL_REFR_PERIOD);
|
|
|
|
}
|
|
int quit_filter(void * userdata, SDL_Event * event)
|
|
{
|
|
(void) userdata;
|
|
|
|
if (event->type == SDL_QUIT) {
|
|
sdl_quit_qry = true;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void monitor_sdl_clean_up(void)
|
|
{
|
|
SDL_DestroyTexture(texture);
|
|
SDL_DestroyRenderer(renderer);
|
|
SDL_DestroyWindow(window);
|
|
SDL_Quit();
|
|
}
|
|
|
|
void monitor_sdl_init(void)
|
|
{
|
|
/*Initialize the SDL*/
|
|
SDL_Init(SDL_INIT_VIDEO);
|
|
|
|
SDL_SetEventFilter(quit_filter, NULL);
|
|
|
|
window = SDL_CreateWindow("TFT Simulator", SDL_WINDOWPOS_UNDEFINED,
|
|
SDL_WINDOWPOS_UNDEFINED,
|
|
MONITOR_HOR_RES * MONITOR_ZOOM, MONITOR_VER_RES * MONITOR_ZOOM, 0); /*last param. SDL_WINDOW_BORDERLESS to hide borders*/
|
|
|
|
renderer = SDL_CreateRenderer(window, -1, 0);
|
|
texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
|
|
SDL_TEXTUREACCESS_STATIC, MONITOR_HOR_RES, MONITOR_VER_RES);
|
|
SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
|
|
|
|
/*Initialize the frame buffer to gray (77 is an empirical value) */
|
|
memset(tft_fb, 0x44, MONITOR_HOR_RES * MONITOR_VER_RES * sizeof(uint32_t));
|
|
SDL_UpdateTexture(texture, NULL, tft_fb,
|
|
MONITOR_HOR_RES * sizeof(uint32_t));
|
|
sdl_refr_qry = true;
|
|
sdl_inited = true;
|
|
}
|
|
|
|
void display_SDL_init()
|
|
{
|
|
SDL_CreateThread(monitor_sdl_refr_thread, "sdl_refr", NULL);
|
|
while (sdl_inited == false)
|
|
; /*Wait until 'sdl_refr' initializes the SDL*/
|
|
}
|
|
|