static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)
{
DisplaySurface *surface = qemu_console_surface(qxl->vga.con);
uint8_t *dst = surface_data(surface);
uint8_t *src;
int len, i;
if (is_buffer_shared(surface)) {
return;
}
trace_qxl_render_blit(qxl->guest_primary.qxl_stride,
rect->left, rect->right, rect->top, rect->bottom);
src = qxl->guest_primary.data;
if (qxl->guest_primary.qxl_stride < 0) {
/* qxl surface is upside down, walk src scanlines
* in reverse order to flip it */
src += (qxl->guest_primary.surface.height - rect->top - 1) *
qxl->guest_primary.abs_stride;
} else {
src += rect->top * qxl->guest_primary.abs_stride;
}
dst += rect->top * qxl->guest_primary.abs_stride;
src += rect->left * qxl->guest_primary.bytes_pp;
dst += rect->left * qxl->guest_primary.bytes_pp;
len = (rect->right - rect->left) * qxl->guest_primary.bytes_pp;
for (i = rect->top; i < rect->bottom; i++) {
memcpy(dst, src, len);
dst += qxl->guest_primary.abs_stride;
src += qxl->guest_primary.qxl_stride;
}
}
static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)
{
uint8_t *src;
uint8_t *dst = ds_get_data(qxl->vga.ds);
int len, i;
if (is_buffer_shared(qxl->vga.ds->surface)) {
return;
}
if (!qxl->guest_primary.data) {
trace_qxl_render_blit_guest_primary_initialized();
qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
}
trace_qxl_render_blit(qxl->guest_primary.qxl_stride,
rect->left, rect->right, rect->top, rect->bottom);
src = qxl->guest_primary.data;
if (qxl->guest_primary.qxl_stride < 0) {
/* qxl surface is upside down, walk src scanlines
* in reverse order to flip it */
src += (qxl->guest_primary.surface.height - rect->top - 1) *
qxl->guest_primary.abs_stride;
} else {
src += rect->top * qxl->guest_primary.abs_stride;
}
dst += rect->top * qxl->guest_primary.abs_stride;
src += rect->left * qxl->guest_primary.bytes_pp;
dst += rect->left * qxl->guest_primary.bytes_pp;
len = (rect->right - rect->left) * qxl->guest_primary.bytes_pp;
for (i = rect->top; i < rect->bottom; i++) {
memcpy(dst, src, len);
dst += qxl->guest_primary.abs_stride;
src += qxl->guest_primary.qxl_stride;
}
}
/*
* Periodic update of display.
* Also transmit the refresh interval to the frontend.
*
* Never ever do any qemu display operations
* (resize, screen update) outside this function.
* Our screen might be inactive. When asked for
* an update we know it is active.
*/
static void xenfb_update(void *opaque)
{
struct XenFB *xenfb = opaque;
DisplaySurface *surface;
int i;
if (xenfb->c.xendev.be_state != XenbusStateConnected)
return;
if (!xenfb->feature_update) {
/* we don't get update notifications, thus use the
* sledge hammer approach ... */
xenfb->up_fullscreen = 1;
}
/* resize if needed */
if (xenfb->do_resize) {
pixman_format_code_t format;
xenfb->do_resize = 0;
switch (xenfb->depth) {
case 16:
case 32:
/* console.c supported depth -> buffer can be used directly */
format = qemu_default_pixman_format(xenfb->depth, true);
surface = qemu_create_displaysurface_from
(xenfb->width, xenfb->height, format,
xenfb->row_stride, xenfb->pixels + xenfb->offset);
break;
default:
/* we must convert stuff */
surface = qemu_create_displaysurface(xenfb->width, xenfb->height);
break;
}
dpy_gfx_replace_surface(xenfb->c.con, surface);
xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
xenfb->width, xenfb->height, xenfb->depth,
is_buffer_shared(surface) ? " (shared)" : "");
xenfb->up_fullscreen = 1;
}
/* run queued updates */
if (xenfb->up_fullscreen) {
xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
} else if (xenfb->up_count) {
xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
for (i = 0; i < xenfb->up_count; i++)
xenfb_guest_copy(xenfb,
xenfb->up_rects[i].x,
xenfb->up_rects[i].y,
xenfb->up_rects[i].w,
xenfb->up_rects[i].h);
} else {
xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n");
}
xenfb->up_count = 0;
xenfb->up_fullscreen = 0;
}
static void sdl_scale(DisplayState *ds, int width, int height)
{
int bpp = real_screen->format->BitsPerPixel;
if (bpp != 16 && bpp != 32) {
bpp = 32;
}
do_sdl_resize(width, height, bpp);
scaling_active = 1;
if (!is_buffer_shared(ds->surface)) {
ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds),
ds_get_height(ds));
dpy_gfx_resize(ds);
}
}
/*
* This copies data from the guest framebuffer region, into QEMU's
* displaysurface. qemu uses 16 or 32 bpp. In case the pv framebuffer
* uses something else we must convert and copy, otherwise we can
* supply the buffer directly and no thing here.
*/
static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h)
{
DisplaySurface *surface = qemu_console_surface(xenfb->c.con);
int line, oops = 0;
int bpp = surface_bits_per_pixel(surface);
int linesize = surface_stride(surface);
uint8_t *data = surface_data(surface);
if (!is_buffer_shared(surface)) {
switch (xenfb->depth) {
case 8:
if (bpp == 16) {
BLT(uint8_t, uint16_t, 3, 3, 2, 5, 6, 5);
} else if (bpp == 32) {
BLT(uint8_t, uint32_t, 3, 3, 2, 8, 8, 8);
} else {
oops = 1;
}
break;
case 24:
if (bpp == 16) {
BLT(uint32_t, uint16_t, 8, 8, 8, 5, 6, 5);
} else if (bpp == 32) {
BLT(uint32_t, uint32_t, 8, 8, 8, 8, 8, 8);
} else {
oops = 1;
}
break;
default:
oops = 1;
}
}
if (oops) /* should not happen */
xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n",
__FUNCTION__, xenfb->depth, bpp);
dpy_gfx_update(xenfb->c.con, x, y, w, h);
}
/*
* Periodic update of display.
* Also transmit the refresh interval to the frontend.
*
* Never ever do any qemu display operations
* (resize, screen update) outside this function.
* Our screen might be inactive. When asked for
* an update we know it is active.
*/
static void xenfb_update(void *opaque)
{
struct XenFB *xenfb = opaque;
struct DisplayChangeListener *l;
int i;
if (xenfb->c.xendev.be_state != XenbusStateConnected)
return;
if (xenfb->feature_update) {
#ifdef XENFB_TYPE_REFRESH_PERIOD
int period = 99999999;
int idle = 1;
if (xenfb_queue_full(xenfb))
return;
for (l = xenfb->c.ds->listeners; l != NULL; l = l->next) {
if (l->idle)
continue;
idle = 0;
if (!l->gui_timer_interval) {
if (period > GUI_REFRESH_INTERVAL)
period = GUI_REFRESH_INTERVAL;
} else {
if (period > l->gui_timer_interval)
period = l->gui_timer_interval;
}
}
if (idle)
period = XENFB_NO_REFRESH;
if (xenfb->refresh_period != period) {
xenfb_send_refresh_period(xenfb, period);
xenfb->refresh_period = period;
xen_be_printf(&xenfb->c.xendev, 1, "refresh period: %d\n", period);
}
#else
; /* nothing */
#endif
} else {
/* we don't get update notifications, thus use the
* sledge hammer approach ... */
xenfb->up_fullscreen = 1;
}
/* resize if needed */
if (xenfb->do_resize) {
xenfb->do_resize = 0;
switch (xenfb->depth) {
case 16:
case 32:
/* console.c supported depth -> buffer can be used directly */
qemu_free_displaysurface(xenfb->c.ds);
xenfb->c.ds->surface = qemu_create_displaysurface_from
(xenfb->width, xenfb->height, xenfb->depth,
xenfb->row_stride, xenfb->pixels + xenfb->offset);
break;
default:
/* we must convert stuff */
qemu_resize_displaysurface(xenfb->c.ds, xenfb->width, xenfb->height);
break;
}
xen_be_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n",
xenfb->width, xenfb->height, xenfb->depth,
is_buffer_shared(xenfb->c.ds->surface) ? " (shared)" : "");
dpy_resize(xenfb->c.ds);
xenfb->up_fullscreen = 1;
}
/* run queued updates */
if (xenfb->up_fullscreen) {
xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n");
xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height);
} else if (xenfb->up_count) {
xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count);
for (i = 0; i < xenfb->up_count; i++)
xenfb_guest_copy(xenfb,
xenfb->up_rects[i].x,
xenfb->up_rects[i].y,
xenfb->up_rects[i].w,
xenfb->up_rects[i].h);
} else {
xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n");
}
xenfb->up_count = 0;
xenfb->up_fullscreen = 0;
}
static void sdl_refresh(DisplayState *ds)
{
SDL_Event ev1, *ev = &ev1;
int mod_state;
int buttonstate = SDL_GetMouseState(NULL, NULL);
if (last_vm_running != vm_running) {
last_vm_running = vm_running;
sdl_update_caption();
}
vga_hw_update();
SDL_EnableUNICODE(!is_graphic_console());
while (SDL_PollEvent(ev)) {
switch (ev->type) {
case SDL_VIDEOEXPOSE:
sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (ev->type == SDL_KEYDOWN) {
if (alt_grab) {
mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
(gui_grab_code | KMOD_LSHIFT);
} else if (ctrl_grab) {
mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
} else {
mod_state = (SDL_GetModState() & gui_grab_code) ==
gui_grab_code;
}
gui_key_modifier_pressed = mod_state;
if (gui_key_modifier_pressed) {
int keycode;
keycode = sdl_keyevent_to_keycode(&ev->key);
switch(keycode) {
case 0x21: /* 'f' key on US keyboard */
toggle_full_screen(ds);
gui_keysym = 1;
break;
case 0x16: /* 'u' key on US keyboard */
scaling_active = 0;
sdl_resize(ds);
vga_hw_invalidate();
vga_hw_update();
break;
case 0x02 ... 0x0a: /* '1' to '9' keys */
/* Reset the modifiers sent to the current console */
reset_keys();
console_select(keycode - 0x02);
if (!is_graphic_console()) {
/* display grab if going to a text console */
if (gui_grab)
sdl_grab_end();
}
gui_keysym = 1;
break;
default:
break;
}
} else if (!is_graphic_console()) {
int keysym;
keysym = 0;
if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
switch(ev->key.keysym.sym) {
case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
default: break;
}
} else {
switch(ev->key.keysym.sym) {
case SDLK_UP: keysym = QEMU_KEY_UP; break;
case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
case SDLK_END: keysym = QEMU_KEY_END; break;
case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
default: break;
}
}
if (keysym) {
kbd_put_keysym(keysym);
} else if (ev->key.keysym.unicode != 0) {
kbd_put_keysym(ev->key.keysym.unicode);
}
}
} else if (ev->type == SDL_KEYUP) {
if (!alt_grab) {
mod_state = (ev->key.keysym.mod & gui_grab_code);
} else {
mod_state = (ev->key.keysym.mod &
(gui_grab_code | KMOD_LSHIFT));
}
if (!mod_state) {
if (gui_key_modifier_pressed) {
gui_key_modifier_pressed = 0;
if (gui_keysym == 0) {
/* exit/enter grab if pressing Ctrl-Alt */
if (!gui_grab) {
/* if the application is not active,
do not try to enter grab state. It
prevents
'SDL_WM_GrabInput(SDL_GRAB_ON)'
from blocking all the application
(SDL bug). */
if (SDL_GetAppState() & SDL_APPACTIVE)
sdl_grab_start();
} else {
sdl_grab_end();
}
/* SDL does not send back all the
modifiers key, so we must correct it */
reset_keys();
break;
}
gui_keysym = 0;
}
}
}
if (is_graphic_console() && !gui_keysym)
sdl_process_key(&ev->key);
break;
case SDL_QUIT:
if (!no_quit)
qemu_system_shutdown_request();
break;
case SDL_MOUSEMOTION:
if (gui_grab || kbd_mouse_is_absolute() ||
absolute_enabled) {
sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
ev->motion.x, ev->motion.y, ev->motion.state);
}
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
SDL_MouseButtonEvent *bev = &ev->button;
if (!gui_grab && !kbd_mouse_is_absolute()) {
if (ev->type == SDL_MOUSEBUTTONDOWN &&
(bev->button == SDL_BUTTON_LEFT)) {
/* start grabbing all events */
sdl_grab_start();
}
} else {
int dz;
dz = 0;
if (ev->type == SDL_MOUSEBUTTONDOWN) {
buttonstate |= SDL_BUTTON(bev->button);
} else {
buttonstate &= ~SDL_BUTTON(bev->button);
}
#ifdef SDL_BUTTON_WHEELUP
if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
dz = -1;
} else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
dz = 1;
}
#endif
sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
}
}
break;
case SDL_ACTIVEEVENT:
if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
!ev->active.gain && !gui_fullscreen_initial_grab) {
sdl_grab_end();
}
if (ev->active.state & SDL_APPACTIVE) {
if (ev->active.gain) {
/* Back to default interval */
dcl->gui_timer_interval = 0;
dcl->idle = 0;
} else {
/* Sleeping interval */
dcl->gui_timer_interval = 500;
dcl->idle = 1;
}
}
break;
case SDL_VIDEORESIZE:
{
SDL_ResizeEvent *rev = &ev->resize;
int bpp = real_screen->format->BitsPerPixel;
if (bpp != 16 && bpp != 32)
bpp = 32;
do_sdl_resize(rev->w, rev->h, bpp);
scaling_active = 1;
if (!is_buffer_shared(ds->surface)) {
ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds), ds_get_height(ds));
dpy_resize(ds);
}
vga_hw_invalidate();
vga_hw_update();
break;
}
default:
break;
}
void qxl_render_update(PCIQXLDevice *qxl)
{
VGACommonState *vga = &qxl->vga;
QXLRect dirty[32], update;
void *ptr;
int i, redraw = 0;
if (!is_buffer_shared(vga->ds->surface)) {
dprint(qxl, 1, "%s: restoring shared displaysurface\n", __func__);
qxl->guest_primary.resized++;
qxl->guest_primary.commands++;
redraw = 1;
}
if (qxl->guest_primary.resized) {
qxl->guest_primary.resized = 0;
if (qxl->guest_primary.flipped) {
g_free(qxl->guest_primary.flipped);
qxl->guest_primary.flipped = NULL;
}
qemu_free_displaysurface(vga->ds);
qxl->guest_primary.data = memory_region_get_ram_ptr(&qxl->vga.vram);
if (qxl->guest_primary.qxl_stride < 0) {
/* spice surface is upside down -> need extra buffer to flip */
qxl->guest_primary.flipped =
g_malloc(qxl->guest_primary.surface.width *
qxl->guest_primary.abs_stride);
ptr = qxl->guest_primary.flipped;
} else {
ptr = qxl->guest_primary.data;
}
dprint(qxl, 1, "%s: %dx%d, stride %d, bpp %d, depth %d, flip %s\n",
__FUNCTION__,
qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.qxl_stride,
qxl->guest_primary.bytes_pp,
qxl->guest_primary.bits_pp,
qxl->guest_primary.flipped ? "yes" : "no");
vga->ds->surface =
qemu_create_displaysurface_from(qxl->guest_primary.surface.width,
qxl->guest_primary.surface.height,
qxl->guest_primary.bits_pp,
qxl->guest_primary.abs_stride,
ptr);
dpy_resize(vga->ds);
}
if (!qxl->guest_primary.commands) {
return;
}
qxl->guest_primary.commands = 0;
update.left = 0;
update.right = qxl->guest_primary.surface.width;
update.top = 0;
update.bottom = qxl->guest_primary.surface.height;
memset(dirty, 0, sizeof(dirty));
qxl_spice_update_area(qxl, 0, &update,
dirty, ARRAY_SIZE(dirty), 1, QXL_SYNC);
if (redraw) {
memset(dirty, 0, sizeof(dirty));
dirty[0] = update;
}
for (i = 0; i < ARRAY_SIZE(dirty); i++) {
if (qemu_spice_rect_is_empty(dirty+i)) {
break;
}
if (qxl->guest_primary.flipped) {
qxl_flip(qxl, dirty+i);
}
dpy_update(vga->ds,
dirty[i].left, dirty[i].top,
dirty[i].right - dirty[i].left,
dirty[i].bottom - dirty[i].top);
}
}
