From a9ff30858f70dec9e0164230d81c2f1d575be586 Mon Sep 17 00:00:00 2001 From: "jinhyung.jo" Date: Tue, 9 Jul 2013 20:46:15 +0900 Subject: [PATCH] display : modified the display sources modified the source to allow the changed display structure Change-Id: Iea72e612e5cb19edf1fab4080354f29a064036e5 Signed-off-by: Jinhyung Jo --- tizen/src/hw/maru_brightness.c | 44 +++++++++---- tizen/src/hw/maru_brightness.h | 2 + tizen/src/hw/maru_overlay.c | 23 +++++++ tizen/src/hw/maru_overlay.h | 4 ++ tizen/src/maru_display.c | 17 +---- tizen/src/maru_sdl.c | 145 ++++++++++++++++++++++++++--------------- tizen/src/maru_sdl.h | 7 +- tizen/src/maru_shm.c | 84 ++++++++++++++++++------ tizen/src/maru_shm.h | 7 +- 9 files changed, 223 insertions(+), 110 deletions(-) diff --git a/tizen/src/hw/maru_brightness.c b/tizen/src/hw/maru_brightness.c index c7285a8..f572d45 100644 --- a/tizen/src/hw/maru_brightness.c +++ b/tizen/src/hw/maru_brightness.c @@ -33,7 +33,7 @@ #include "hw/i386/pc.h" #ifdef TARGET_ARM -#include "console.h" +#include "ui/console.h" #endif #include "hw/pci/pci.h" #include "maru_device_ids.h" @@ -61,20 +61,22 @@ enum { uint32_t brightness_level = BRIGHTNESS_MAX; uint32_t brightness_off; +pixman_color_t level_color; +pixman_image_t *brightness_image; /* level : 1 ~ 100, interval : 1 or 2 */ /* skip 100 level, set to default alpha */ -uint8_t brightness_tbl[] = {100, /* level 0 : for dimming */ -/* level 01 ~ 10 */ 106, 108, 109, 111, 112, 114, 115, 117, 118, 120, -/* level 11 ~ 20 */ 121, 123, 124, 126, 127, 129, 130, 132, 133, 135, -/* level 21 ~ 30 */ 136, 138, 139, 141, 142, 144, 145, 147, 148, 150, -/* level 31 ~ 40 */ 151, 153, 154, 156, 157, 159, 160, 162, 163, 165, -/* level 41 ~ 50 */ 166, 168, 169, 171, 172, 174, 175, 177, 178, 180, -/* level 51 ~ 60 */ 181, 183, 184, 186, 187, 189, 190, 192, 193, 195, -/* level 61 ~ 70 */ 196, 198, 199, 201, 202, 204, 205, 207, 208, 210, -/* level 71 ~ 80 */ 211, 213, 214, 216, 217, 219, 220, 222, 223, 225, -/* level 81 ~ 90 */ 226, 228, 229, 231, 232, 234, 235, 237, 238, 240, -/* level 91 ~ 99 */ 241, 243, 244, 246, 247, 249, 250, 252, 253}; +uint8_t brightness_tbl[] = {155, /* level 0 : for dimming */ +/* level 01 ~ 10 */ 149, 147, 146, 144, 143, 141, 140, 138, 137, 135, +/* level 11 ~ 20 */ 134, 132, 131, 129, 128, 126, 125, 123, 122, 120, +/* level 21 ~ 30 */ 119, 117, 116, 114, 113, 111, 110, 108, 107, 105, +/* level 31 ~ 40 */ 104, 102, 101, 99, 98, 96, 95, 93, 92, 90, +/* level 41 ~ 50 */ 89, 87, 86, 84, 83, 81, 80, 78, 77, 75, +/* level 51 ~ 60 */ 74, 72, 71, 69, 68, 66, 65, 63, 62, 60, +/* level 61 ~ 70 */ 59, 57, 56, 54, 53, 51, 50, 48, 47, 45, +/* level 71 ~ 80 */ 44, 42, 41, 39, 38, 36, 35, 33, 32, 30, +/* level 81 ~ 90 */ 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, +/* level 91 ~ 99 */ 14, 12, 11, 9, 8, 6, 5, 3, 2}; QEMUBH *bh; @@ -112,9 +114,14 @@ static void brightness_reg_write(void *opaque, ERR("brightness_reg_write: Invalide brightness level.\n"); } else { brightness_level = val; + if (brightness_image) { + pixman_image_unref(brightness_image); + } + level_color.alpha = brightness_tbl[brightness_level] << 8; + brightness_image = pixman_image_create_solid_fill(&level_color); INFO("brightness_level : %lld\n", val); #ifdef TARGET_ARM - vga_hw_invalidate(); + graphic_hw_invalidate(NULL); #endif } return; @@ -127,7 +134,7 @@ static void brightness_reg_write(void *opaque, brightness_off = val; #ifdef TARGET_ARM - vga_hw_invalidate(); + graphic_hw_invalidate(NULL); #endif /* notify to skin process */ @@ -151,6 +158,9 @@ static void brightness_exitfn(PCIDevice *dev) if (bh) { qemu_bh_delete(bh); } + if (brightness_image) { + pixman_image_unref(brightness_image); + } } static void maru_brightness_bh(void *opaque) @@ -177,6 +187,12 @@ static int brightness_initfn(PCIDevice *dev) bh = qemu_bh_new(maru_brightness_bh, s); + level_color.alpha = 0x0000; + level_color.red = 0x0000; + level_color.green = 0x0000; + level_color.blue = 0x0000; + brightness_image = pixman_image_create_solid_fill(&level_color); + return 0; } diff --git a/tizen/src/hw/maru_brightness.h b/tizen/src/hw/maru_brightness.h index 98787c3..9ecaccb 100644 --- a/tizen/src/hw/maru_brightness.h +++ b/tizen/src/hw/maru_brightness.h @@ -33,6 +33,7 @@ #define MARU_BRIGHTNESS_H_ #include "qemu-common.h" +#include "ui/qemu-pixman.h" #define BRIGHTNESS_MIN (0) #define BRIGHTNESS_MAX (100) @@ -40,6 +41,7 @@ extern uint32_t brightness_level; extern uint32_t brightness_off; extern uint8_t brightness_tbl[]; +extern pixman_image_t *brightness_image; DeviceState *pci_maru_brightness_init(PCIBus *bus); diff --git a/tizen/src/hw/maru_overlay.c b/tizen/src/hw/maru_overlay.c index f7ffa46..55fbea6 100644 --- a/tizen/src/hw/maru_overlay.c +++ b/tizen/src/hw/maru_overlay.c @@ -65,6 +65,9 @@ uint16_t overlay1_top; uint16_t overlay1_width; uint16_t overlay1_height; +pixman_image_t *overlay0_image; +pixman_image_t *overlay1_image; + typedef struct OverlayState { PCIDevice dev; @@ -127,7 +130,17 @@ static void overlay_reg_write(void *opaque, /* clear the last overlay area. */ memset(overlay_ptr, 0x00, (OVERLAY_MEM_SIZE / 2)); overlay0_left = overlay0_top = overlay0_width = overlay0_height = 0; + if (overlay0_image) { + pixman_image_unref(overlay0_image); + overlay0_image = NULL; + } TRACE("clear the last overlay0 area\n"); + } else { + overlay0_image = pixman_image_create_bits(PIXMAN_a8r8g8b8, + overlay0_width, overlay0_height, + (uint32_t *)overlay_ptr, + overlay0_width * 4); + TRACE("create the overlay0 pixman image\n"); } break; case OVERLAY_POSITION: @@ -150,7 +163,17 @@ static void overlay_reg_write(void *opaque, memset(overlay_ptr + OVERLAY1_REG_OFFSET, 0x00, (OVERLAY_MEM_SIZE / 2)); overlay1_left = overlay1_top = overlay1_width = overlay1_height = 0; + if (overlay1_image) { + pixman_image_unref(overlay1_image); + overlay1_image = NULL; + } TRACE("clear the last overlay1 area\n"); + } else { + overlay1_image = pixman_image_create_bits(PIXMAN_a8r8g8b8, + overlay1_width, overlay1_height, + (uint32_t *)(overlay_ptr + OVERLAY1_REG_OFFSET), + overlay1_width * 4); + TRACE("create the overlay1 pixman image\n"); } break; case OVERLAY1_REG_OFFSET + OVERLAY_POSITION: diff --git a/tizen/src/hw/maru_overlay.h b/tizen/src/hw/maru_overlay.h index 24a4529..06ea812 100644 --- a/tizen/src/hw/maru_overlay.h +++ b/tizen/src/hw/maru_overlay.h @@ -34,6 +34,7 @@ #define MARU_OVERLAY_H_ #include "qemu-common.h" +#include "ui/qemu-pixman.h" extern uint8_t *overlay_ptr; extern uint8_t overlay0_power; @@ -48,6 +49,9 @@ extern uint16_t overlay1_top; extern uint16_t overlay1_width; extern uint16_t overlay1_height; +extern pixman_image_t *overlay0_image; +extern pixman_image_t *overlay1_image; + DeviceState *pci_maru_overlay_init(PCIBus *bus); #endif /* MARU_OVERLAY_H_ */ diff --git a/tizen/src/maru_display.c b/tizen/src/maru_display.c index a574e55..ae5c4be 100644 --- a/tizen/src/maru_display.c +++ b/tizen/src/maru_display.c @@ -56,22 +56,7 @@ void maru_display_init(DisplayState *ds) DisplayChangeListener *dcl; dcl = g_malloc0(sizeof(DisplayChangeListener)); -// FIXME: merge -#if 0 -#ifndef CONFIG_USE_SHM - /* sdl library */ - dcl->dpy_update = qemu_ds_sdl_update; - dcl->dpy_resize = qemu_ds_sdl_resize; - dcl->dpy_refresh = qemu_ds_sdl_refresh; -#else - /* shared memroy */ - dcl->dpy_update = qemu_ds_shm_update; - dcl->dpy_resize = qemu_ds_shm_resize; - dcl->dpy_refresh = qemu_ds_shm_refresh; -#endif -#endif - -// register_displaychangelistener(ds, dcl); + dcl->ops = &maru_dcl_ops; register_displaychangelistener(dcl); maru_screenshot = g_malloc0(sizeof(MaruScreenshot)); diff --git a/tizen/src/maru_sdl.c b/tizen/src/maru_sdl.c index 5b7b7a1..ffbc50a 100644 --- a/tizen/src/maru_sdl.c +++ b/tizen/src/maru_sdl.c @@ -31,25 +31,20 @@ #include #include -#include #include "ui/console.h" #include "maru_sdl.h" #include "maru_display.h" #include "emul_state.h" -/* -#include "SDL_gfx/SDL_rotozoom.h" -#include "maru_sdl_rotozoom.h" -*/ #include "maru_finger.h" #include "hw/maru_pm.h" #include "hw/maru_brightness.h" +#include "hw/maru_overlay.h" #include "debug_ch.h" /* #include "SDL_opengl.h" */ MULTI_DEBUG_CHANNEL(tizen, maru_sdl); - -DisplaySurface* qemu_display_surface = NULL; +DisplaySurface *qemu_display_surface = NULL; static SDL_Surface *surface_screen; static SDL_Surface *surface_qemu; @@ -87,6 +82,32 @@ extern pthread_cond_t cond_screenshot; #define SDL_BPP 32 /* Image processing functions using the pixman library */ +static void maru_do_pixman_sdl(pixman_image_t *dst_image) +{ + /* overlay0 */ + if (overlay0_power) { + pixman_image_composite(PIXMAN_OP_OVER, + overlay0_image, NULL, dst_image, + 0, 0, 0, 0, overlay0_left, overlay0_top, + overlay0_width, overlay0_height); + } + /* overlay1 */ + if (overlay1_power) { + pixman_image_composite(PIXMAN_OP_OVER, + overlay1_image, NULL, dst_image, + 0, 0, 0, 0, overlay1_left, overlay1_top, + overlay1_width, overlay1_height); + } + /* apply the brightness level */ + if (brightness_level < BRIGHTNESS_MAX) { + pixman_image_composite(PIXMAN_OP_OVER, + brightness_image, NULL, dst_image, + 0, 0, 0, 0, 0, 0, + pixman_image_get_width(dst_image), + pixman_image_get_height(dst_image)); + } +} + static SDL_Surface *maru_do_pixman_scale(SDL_Surface *rz_src, SDL_Surface *rz_dst, int angle) @@ -151,7 +172,8 @@ static SDL_Surface *maru_do_pixman_rotate(SDL_Surface *rz_src, break; case 90: pixman_f_transform_rotate(&matrix_f, NULL, 0.0, 1.0); - pixman_f_transform_translate(&matrix_f, NULL, (double)rz_dst->h, 0.0); + pixman_f_transform_translate(&matrix_f, NULL, + (double)rz_dst->h, 0.0); break; case 180: pixman_f_transform_rotate(&matrix_f, NULL, -1.0, 0.0); @@ -160,7 +182,8 @@ static SDL_Surface *maru_do_pixman_rotate(SDL_Surface *rz_src, break; case 270: pixman_f_transform_rotate(&matrix_f, NULL, 0.0, -1.0); - pixman_f_transform_translate(&matrix_f, NULL, 0.0, (double)rz_dst->w); + pixman_f_transform_translate(&matrix_f, NULL, + 0.0, (double)rz_dst->w); break; default: fprintf(stdout, "not supported angle factor (angle=%d)\n", angle); @@ -182,7 +205,8 @@ static SDL_Surface *maru_do_pixman_rotate(SDL_Surface *rz_src, return rz_dst; } -void qemu_ds_sdl_update(DisplayState *ds, int x, int y, int w, int h) +static void qemu_ds_sdl_update(DisplayChangeListener *dcl, + int x, int y, int w, int h) { /* call sdl update */ #ifdef SDL_THREAD @@ -203,12 +227,11 @@ void qemu_ds_sdl_update(DisplayState *ds, int x, int y, int w, int h) maru_screenshot->isReady = 1; if (maru_screenshot->request_screenshot == 1) { -// FIXME: merge -#if 0 - memcpy(maru_screenshot->pixel_data, ds->surface->data, - ds->surface->linesize * ds->surface->height); + memcpy(maru_screenshot->pixel_data, + surface_data(qemu_display_surface), + surface_stride(qemu_display_surface) * + surface_height(qemu_display_surface)); maru_screenshot->request_screenshot = 0; -#endif pthread_cond_signal(&cond_screenshot); } @@ -217,14 +240,21 @@ void qemu_ds_sdl_update(DisplayState *ds, int x, int y, int w, int h) pthread_mutex_unlock(&mutex_screenshot); } -void qemu_ds_sdl_resize(DisplayState *ds) +static void qemu_ds_sdl_switch(DisplayChangeListener *dcl, + struct DisplaySurface *new_surface) { int w, h; - w = ds_get_width(ds); - h = ds_get_height(ds); + if (!new_surface) { + ERR("qemu_ds_sdl_switch: new_surface is NULL\n"); + return; + } + + qemu_display_surface = new_surface; + w = surface_width(new_surface); + h = surface_height(new_surface); - INFO("qemu_ds_sdl_resize = (%d, %d)\n", w, h); + INFO("qemu_ds_sdl_switch = (%d, %d)\n", w, h); #ifdef SDL_THREAD pthread_mutex_lock(&sdl_mutex); @@ -237,20 +267,22 @@ void qemu_ds_sdl_resize(DisplayState *ds) /* create surface_qemu */ if (w == get_emul_lcd_width() && h == get_emul_lcd_height()) { -// FIXME: merge -#if 0 - surface_qemu = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), w, h, - ds_get_bits_per_pixel(ds), - ds_get_linesize(ds), - ds->surface->pf.rmask, - ds->surface->pf.gmask, - ds->surface->pf.bmask, - ds->surface->pf.amask); -#endif + INFO("create SDL screen = (%d, %d)\n", + get_emul_lcd_width(), get_emul_lcd_height()); + surface_qemu = SDL_CreateRGBSurfaceFrom( + surface_data(qemu_display_surface), + w, h, + surface_bits_per_pixel(qemu_display_surface), + surface_stride(qemu_display_surface), + qemu_display_surface->pf.rmask, + qemu_display_surface->pf.gmask, + qemu_display_surface->pf.bmask, + qemu_display_surface->pf.amask); } else { - INFO("create blank screen = (%d, %d)\n", get_emul_lcd_width(), get_emul_lcd_height()); + INFO("create blank screen = (%d, %d)\n", + get_emul_lcd_width(), get_emul_lcd_height()); surface_qemu = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, - ds_get_bits_per_pixel(ds), 0, 0, 0, 0); + surface_bits_per_pixel(qemu_display_surface), 0, 0, 0, 0); } #ifdef SDL_THREAD @@ -276,22 +308,20 @@ static int maru_sdl_poll_event(SDL_Event *ev) return ret; } -void qemu_ds_sdl_refresh(DisplayState *ds) +static void qemu_ds_sdl_refresh(DisplayChangeListener *dcl) { SDL_Event ev1, *ev = &ev1; static uint32_t sdl_skip_count = 0; - // surface may be NULL in init func. -// FIXME: merge -// qemu_display_surface = ds->surface; - while (maru_sdl_poll_event(ev)) { switch (ev->type) { case SDL_VIDEORESIZE: { pthread_mutex_lock(&sdl_mutex); - maruskin_sdl_init(0, get_emul_lcd_width(), get_emul_lcd_height(), true); + maruskin_sdl_init(0, + get_emul_lcd_width(), get_emul_lcd_height(), + true); pthread_mutex_unlock(&sdl_mutex); sdl_skip_update = 0; @@ -313,14 +343,15 @@ void qemu_ds_sdl_refresh(DisplayState *ds) /* Usually, continuously updated. When the LCD is turned off, ten more updates the screen for a black screen. */ - vga_hw_update(); if (brightness_off) { + dpy_gfx_update(dcl->con, 0, 0, 0, 0); if (++sdl_skip_count > 10) { sdl_skip_update = 1; } else { sdl_skip_update = 0; } } else { + graphic_hw_update(dcl->con); sdl_skip_count = 0; sdl_skip_update = 0; } @@ -343,12 +374,20 @@ void qemu_ds_sdl_refresh(DisplayState *ds) #endif } +DisplayChangeListenerOps maru_dcl_ops = { + .dpy_name = "maru_sdl", + .dpy_gfx_update = qemu_ds_sdl_update, + .dpy_gfx_switch = qemu_ds_sdl_switch, + .dpy_refresh = qemu_ds_sdl_refresh, +}; + //extern int capability_check_gl; static void _sdl_init(void) { int w, h, rwidth, rheight, temp; - INFO("Set up a video mode with the specified width, height and bits-per-pixel\n"); + INFO("Set up a video mode with the specified width, " + "height and bits-per-pixel\n"); //get current setting information and calculate screen size rwidth = get_emul_lcd_width(); @@ -394,9 +433,12 @@ static void _sdl_init(void) ERR("%s\n", SDL_GetError()); #endif - surface_screen = SDL_SetVideoMode(w, h, get_emul_sdl_bpp(), SDL_FLAGS); + surface_screen = SDL_SetVideoMode(w, h, + get_emul_sdl_bpp(), + SDL_FLAGS); if (surface_screen == NULL) { - ERR("Could not open SDL display (%dx%dx%d): %s\n", w, h, get_emul_sdl_bpp(), SDL_GetError()); + ERR("Could not open SDL display (%dx%dx%d): %s\n", + w, h, get_emul_sdl_bpp(), SDL_GetError()); return; } #if 0 @@ -575,8 +617,8 @@ static void qemu_update(void) else { //sdl surface #endif - if (current_scale_factor != 1.0) - { + maru_do_pixman_sdl(qemu_display_surface->image); + if (current_scale_factor != 1.0) { rotated_screen = maru_do_pixman_rotate( surface_qemu, rotated_screen, (int)current_screen_degree); @@ -585,8 +627,7 @@ static void qemu_update(void) (int)current_screen_degree); SDL_BlitSurface(scaled_screen, NULL, surface_screen, NULL); } - else /* current_scale_factor == 1.0 */ - { + else {/* current_scale_factor == 1.0 */ if (current_screen_degree != 0.0) { rotated_screen = maru_do_pixman_rotate( surface_qemu, rotated_screen, @@ -612,7 +653,9 @@ static void qemu_update(void) rect.y = finger->origin_y - finger_point_size_half; rect.w = rect.h = mts->finger_point_size; - SDL_BlitSurface((SDL_Surface *)mts->finger_point_surface, NULL, surface_screen, &rect); + SDL_BlitSurface( + (SDL_Surface *)mts->finger_point_surface, + NULL, surface_screen, &rect); } } } /* end of draw multi-touch */ @@ -623,17 +666,17 @@ static void qemu_update(void) #ifdef SDL_THREAD -static void* run_qemu_update(void* arg) +static void *run_qemu_update(void* arg) { - while(1) { + while(1) { pthread_mutex_lock(&sdl_mutex); - pthread_cond_wait(&sdl_cond, &sdl_mutex); + pthread_cond_wait(&sdl_cond, &sdl_mutex); qemu_update(); pthread_mutex_unlock(&sdl_mutex); - } + } return NULL; } @@ -725,7 +768,7 @@ void maruskin_sdl_resize(void) SDL_PushEvent(&ev); } -DisplaySurface* maruskin_sdl_get_display(void) { +DisplaySurface *maruskin_sdl_get_display(void) { return qemu_display_surface; } diff --git a/tizen/src/maru_sdl.h b/tizen/src/maru_sdl.h index f2276c1..d2d8f8f 100644 --- a/tizen/src/maru_sdl.h +++ b/tizen/src/maru_sdl.h @@ -31,15 +31,12 @@ #ifndef MARU_SDL_H_ #define MARU_SDL_H_ -#include "ui/console.h" #include #include +#include "ui/console.h" #include "qemu-common.h" - -void qemu_ds_sdl_update(DisplayState *ds, int x, int y, int w, int h); -void qemu_ds_sdl_resize(DisplayState *ds); -void qemu_ds_sdl_refresh(DisplayState *ds); +extern DisplayChangeListenerOps maru_dcl_ops; void maruskin_sdl_init(uint64 swt_handle, int lcd_size_width, int lcd_size_height, bool is_resize); void maruskin_sdl_resize(void); diff --git a/tizen/src/maru_shm.c b/tizen/src/maru_shm.c index 3204e75..c1b938f 100644 --- a/tizen/src/maru_shm.c +++ b/tizen/src/maru_shm.c @@ -28,20 +28,21 @@ */ +#include +#include +#include + #include "maru_shm.h" #include "emul_state.h" #include "hw/maru_brightness.h" +#include "hw/maru_overlay.h" #include "skin/maruskin_server.h" #include "debug_ch.h" - -#include -#include -#include #include "maru_err_table.h" MULTI_DEBUG_CHANNEL(tizen, maru_shm); - +static DisplaySurface *shm_surface; static void *shared_memory = (void*) 0; static int skin_shmid; @@ -56,7 +57,34 @@ static unsigned int draw_frame; static unsigned int drop_frame; #endif -void qemu_ds_shm_update(DisplayState *ds, int x, int y, int w, int h) +static void maru_do_pixman_shm(void) +{ + /* overlay0 */ + if (overlay0_power) { + pixman_image_composite(PIXMAN_OP_OVER, + overlay0_image, NULL, shm_surface->image, + 0, 0, 0, 0, overlay0_left, overlay0_top, + overlay0_width, overlay0_height); + } + /* overlay1 */ + if (overlay1_power) { + pixman_image_composite(PIXMAN_OP_OVER, + overlay1_image, NULL, shm_surface->image, + 0, 0, 0, 0, overlay1_left, overlay1_top, + overlay1_width, overlay1_height); + } + /* apply the brightness level */ + if (brightness_level < BRIGHTNESS_MAX) { + pixman_image_composite(PIXMAN_OP_OVER, + brightness_image, NULL, shm_surface->image, + 0, 0, 0, 0, 0, 0, + surface_width(shm_surface), + surface_height(shm_surface)); + } +} + +static void qemu_ds_shm_update(DisplayChangeListener *dcl, + int x, int y, int w, int h) { if (shared_memory != NULL) { pthread_mutex_lock(&mutex_draw_display); @@ -64,38 +92,49 @@ void qemu_ds_shm_update(DisplayState *ds, int x, int y, int w, int h) if (draw_display_state == 0) { draw_display_state = 1; pthread_mutex_unlock(&mutex_draw_display); - - memcpy(shared_memory, ds->surface->data, - ds->surface->linesize * ds->surface->height); - + if (brightness_off) { + memset(shared_memory, + 0x00, + surface_stride(shm_surface) * + surface_height(shm_surface)); + } else { + maru_do_pixman_shm(); + memcpy(shared_memory, + surface_data(shm_surface), + surface_stride(shm_surface) * + surface_height(shm_surface)); + } #ifdef INFO_FRAME_DROP_RATE draw_frame++; #endif - notify_draw_frame(); } else { #ifdef INFO_FRAME_DROP_RATE drop_frame++; #endif - pthread_mutex_unlock(&mutex_draw_display); } - #ifdef INFO_FRAME_DROP_RATE - INFO("! frame drop rate = (%d/%d)\n", drop_frame, draw_frame + drop_frame); + INFO("! frame drop rate = (%d/%d)\n", + drop_frame, draw_frame + drop_frame); #endif } } -void qemu_ds_shm_resize(DisplayState *ds) +static void qemu_ds_shm_switch(DisplayChangeListener *dcl, + struct DisplaySurface *new_surface) { - TRACE("qemu_ds_shm_resize\n"); + TRACE("qemu_ds_shm_switch\n"); + + if (new_surface) { + shm_surface = new_surface; + } shm_skip_update = 0; shm_skip_count = 0; } -void qemu_ds_shm_refresh(DisplayState *ds) +static void qemu_ds_shm_refresh(DisplayChangeListener *dcl) { /* If the display is turned off, the screen does not update until the it is turned on */ @@ -103,23 +142,30 @@ void qemu_ds_shm_refresh(DisplayState *ds) return; } - vga_hw_update(); - /* Usually, continuously updated. But when the display is turned off, ten more updates the surface for a black screen. */ if (brightness_off) { + dpy_gfx_update(dcl->con, 0, 0, 0, 0); if (++shm_skip_count > 10) { shm_skip_update = 1; } else { shm_skip_update = 0; } } else { + graphic_hw_update(dcl->con); shm_skip_count = 0; shm_skip_update = 0; } } +DisplayChangeListenerOps maru_dcl_ops = { + .dpy_name = "maru_shm", + .dpy_refresh = qemu_ds_shm_refresh, + .dpy_gfx_update = qemu_ds_shm_update, + .dpy_gfx_switch = qemu_ds_shm_switch, +}; + void maruskin_shm_init(uint64 swt_handle, int lcd_size_width, int lcd_size_height, bool is_resize) { diff --git a/tizen/src/maru_shm.h b/tizen/src/maru_shm.h index 1e7e6c5..2b73ad8 100644 --- a/tizen/src/maru_shm.h +++ b/tizen/src/maru_shm.h @@ -31,12 +31,9 @@ #ifndef MARU_SHM_H_ #define MARU_SHM_H_ -#include "console.h" +#include "ui/console.h" - -void qemu_ds_shm_update(DisplayState *ds, int x, int y, int w, int h); -void qemu_ds_shm_resize(DisplayState *ds); -void qemu_ds_shm_refresh(DisplayState *ds); +extern DisplayChangeListenerOps maru_dcl_ops; void maruskin_shm_init(uint64 swt_handle, int lcd_size_width, int lcd_size_height, bool is_resize); -- 2.7.4