screen.c

   1 /*
   2
   3      Copyright (C) 2013 Proxmox Server Solutions GmbH
   4
   5      Copyright: spiceterm is under GNU GPL, the GNU General Public License.
   6
   7      This program is free software; you can redistribute it and/or modify
   8      it under the terms of the GNU General Public License as published by
   9      the Free Software Foundation; version 2 dated June, 1991.
  10
  11      This program is distributed in the hope that it will be useful,
  12      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14      GNU General Public License for more details.
  15
  16      You should have received a copy of the GNU General Public License
  17      along with this program; if not, write to the Free Software
  18      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19      02111-1307, USA.
  20
  21      Author: Dietmar Maurer <dietmar@proxmox.com>
  22
  23      Note: qlx drawing code is copied from spice-server test code.
  24
  25 */
  26
  27 #include <stdlib.h>
  28 #include <math.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <unistd.h>
  32 #include <signal.h>
  33 #include <wait.h>
  34 #include <sys/select.h>
  35 #include <sys/types.h>
  36 #include <getopt.h>
  37
  38 #include <spice.h>
  39 #include <spice/enums.h>
  40 #include <spice/macros.h>
  41 #include <spice/qxl_dev.h>
  42 #include <spice/vd_agent.h>
  43
  44 #include "glyphs.h"
  45
  46 #include "spiceterm.h"
  47
  48 static int debug = 0;
  49
  50 #define DPRINTF(x, format, ...) { \
  51     if (x <= debug) { \
  52         printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
  53     } \
  54 }
  55
  56 #define MEM_SLOT_GROUP_ID 0
  57
  58 #define NOTIFY_DISPLAY_BATCH (SINGLE_PART/2)
  59 #define NOTIFY_CURSOR_BATCH 10
  60
  61 /* these colours are from linux kernel drivers/char/vt.c */
  62 /* the default colour table, for VGA+ colour systems */
  63 int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
  64     0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
  65 int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
  66     0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
  67 int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
  68     0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
  69
  70 /* Parts cribbed from spice-display.h/.c/qxl.c */
  71
  72 typedef struct SimpleSpiceUpdate {
  73     QXLCommandExt ext; // first
  74     QXLDrawable drawable;
  75     QXLImage image;
  76     uint8_t *bitmap;
  77 } SimpleSpiceUpdate;
  78
  79 static void
  80 spice_screen_destroy_update(SimpleSpiceUpdate *update)
  81 {
  82     if (!update) {
  83         return;
  84     }
  85     if (update->drawable.clip.type != SPICE_CLIP_TYPE_NONE) {
  86         uint8_t *ptr = (uint8_t*)update->drawable.clip.data;
  87         free(ptr);
  88     }
  89     g_free(update->bitmap);
  90     g_free(update);
  91 }
  92
  93 #define DEFAULT_WIDTH 640
  94 #define DEFAULT_HEIGHT 320
  95
  96 static int unique = 0x0ffff + 1;
  97
  98 static void
  99 set_cmd(QXLCommandExt *ext, uint32_t type, QXLPHYSICAL data)
 100 {
 101     ext->cmd.type = type;
 102     ext->cmd.data = data;
 103     ext->cmd.padding = 0;
 104     ext->group_id = MEM_SLOT_GROUP_ID;
 105     ext->flags = 0;
 106 }
 107
 108 static void
 109 simple_set_release_info(QXLReleaseInfo *info, intptr_t ptr)
 110 {
 111     info->id = ptr;
 112     //info->group_id = MEM_SLOT_GROUP_ID;
 113 }
 114
 115 /* Note: push_command/get_command are called from different threads */
 116
 117 static void
 118 push_command(SpiceScreen *spice_screen, QXLCommandExt *ext)
 119 {
 120     g_mutex_lock(spice_screen->command_mutex);
 121
 122     while (spice_screen->commands_end - spice_screen->commands_start >= COMMANDS_SIZE) {
 123         g_cond_wait(spice_screen->command_cond, spice_screen->command_mutex);
 124     }
 125
 126     g_assert(spice_screen->commands_end - spice_screen->commands_start < COMMANDS_SIZE);
 127
 128     spice_screen->commands[spice_screen->commands_end % COMMANDS_SIZE] = ext;
 129     spice_screen->commands_end++;
 130
 131     g_mutex_unlock(spice_screen->command_mutex);
 132
 133     spice_screen->qxl_worker->wakeup(spice_screen->qxl_worker);
 134 }
 135
 136 /* bitmap are freed, so they must be allocated with g_malloc */
 137 static SimpleSpiceUpdate *
 138 spice_screen_update_from_bitmap_cmd(uint32_t surface_id, QXLRect bbox, uint8_t *bitmap, int cache_id)
 139 {
 140     SimpleSpiceUpdate *update;
 141     QXLDrawable *drawable;
 142     QXLImage *image;
 143     uint32_t bw, bh;
 144
 145     bh = bbox.bottom - bbox.top;
 146     bw = bbox.right - bbox.left;
 147
 148     update   = g_new0(SimpleSpiceUpdate, 1);
 149     update->bitmap = bitmap;
 150     drawable = &update->drawable;
 151     image    = &update->image;
 152
 153     drawable->surface_id      = surface_id;
 154
 155     drawable->bbox            = bbox;
 156     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
 157     drawable->effect          = QXL_EFFECT_OPAQUE;
 158     simple_set_release_info(&drawable->release_info, (intptr_t)update);
 159     drawable->type            = QXL_DRAW_COPY;
 160     drawable->surfaces_dest[0] = -1;
 161     drawable->surfaces_dest[1] = -1;
 162     drawable->surfaces_dest[2] = -1;
 163
 164     drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
 165     drawable->u.copy.src_bitmap      = (intptr_t)image;
 166     drawable->u.copy.src_area.right  = bw;
 167     drawable->u.copy.src_area.bottom = bh;
 168
 169     if (cache_id) {
 170         QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, cache_id);
 171     } else {
 172         QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, ++unique);
 173     }
 174     image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
 175     image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
 176     image->bitmap.stride     = bw * 4;
 177     image->descriptor.width  = image->bitmap.x = bw;
 178     image->descriptor.height = image->bitmap.y = bh;
 179     image->bitmap.data = (intptr_t)bitmap;
 180     image->bitmap.palette = 0;
 181     image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
 182
 183     set_cmd(&update->ext, QXL_CMD_DRAW, (intptr_t)drawable);
 184
 185     return update;
 186 }
 187
 188 static SimpleSpiceUpdate *
 189 spice_screen_draw_char_cmd(SpiceScreen *spice_screen, int x, int y, int c,
 190                            int fg, int bg, gboolean uline)
 191 {
 192     int top, left;
 193     uint8_t *dst;
 194     uint8_t *bitmap;
 195     int bw, bh;
 196     int i, j;
 197     QXLRect bbox;
 198     int cache_id = 0;
 199
 200     if (!uline && c < 256) {
 201         cache_id = ((fg << 12) | (bg << 8) | (c & 255)) & 0x0ffff;
 202     }
 203
 204     left = x*8;
 205     top = y*16;
 206
 207     bw       = 8;
 208     bh       = 16;
 209
 210     bitmap = dst = g_malloc(bw * bh * 4);
 211
 212     unsigned char *data = vt_font_data + c*16;
 213     unsigned char d = *data;
 214
 215     g_assert(fg >= 0 && fg < 16);
 216     g_assert(bg >= 0 && bg < 16);
 217
 218     unsigned char fgc_red = default_red[fg];
 219     unsigned char fgc_blue = default_blu[fg];
 220     unsigned char fgc_green = default_grn[fg];
 221     unsigned char bgc_red = default_red[bg];
 222     unsigned char bgc_blue = default_blu[bg];
 223     unsigned char bgc_green = default_grn[bg];
 224
 225     for (j = 0; j < 16; j++) {
 226         gboolean ul = (j == 14) && uline;
 227         for (i = 0; i < 8; i++) {
 228             if (i == 0) {
 229                 d=*data;
 230                 data++;
 231             }
 232             if (ul || d&0x80) {
 233                  *(dst) = fgc_blue;
 234                  *(dst+1) = fgc_green;
 235                  *(dst+2) = fgc_red;
 236                  *(dst+3) = 0;
 237             } else {
 238                  *(dst) = bgc_blue;
 239                  *(dst+1) = bgc_green;
 240                  *(dst+2) = bgc_red;
 241                  *(dst+3) = 0;
 242             }
 243             d<<=1;
 244             dst += 4;
 245         }
 246     }
 247
 248     bbox.left = left; bbox.top = top;
 249     bbox.right = left + bw; bbox.bottom = top + bh;
 250
 251     return spice_screen_update_from_bitmap_cmd(0, bbox, bitmap, cache_id);
 252 }
 253
 254 void
 255 spice_screen_scroll(SpiceScreen *spice_screen, int x1, int y1,
 256                     int x2, int y2, int src_x, int src_y)
 257 {
 258     SimpleSpiceUpdate *update;
 259     QXLDrawable *drawable;
 260     QXLRect bbox;
 261
 262     int surface_id = 0;
 263
 264     update   = g_new0(SimpleSpiceUpdate, 1);
 265     drawable = &update->drawable;
 266
 267     bbox.left = x1;
 268     bbox.top = y1;
 269     bbox.right = x2;
 270     bbox.bottom = y2;
 271
 272     drawable->surface_id = surface_id;
 273
 274     drawable->bbox            = bbox;
 275     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
 276     drawable->effect          = QXL_EFFECT_OPAQUE;
 277     simple_set_release_info(&drawable->release_info, (intptr_t)update);
 278     drawable->type            = QXL_COPY_BITS;
 279     drawable->surfaces_dest[0] = -1;
 280     drawable->surfaces_dest[1] = -1;
 281     drawable->surfaces_dest[2] = -1;
 282
 283     drawable->u.copy_bits.src_pos.x = src_x;
 284     drawable->u.copy_bits.src_pos.y = src_y;
 285
 286     set_cmd(&update->ext, QXL_CMD_DRAW, (intptr_t)drawable);
 287
 288     push_command(spice_screen, &update->ext);
 289 }
 290
 291 void
 292 spice_screen_clear(SpiceScreen *spice_screen, int x1, int y1, int x2, int y2)
 293 {
 294     SimpleSpiceUpdate *update;
 295     QXLDrawable *drawable;
 296     QXLRect bbox;
 297
 298     int surface_id = 0;
 299
 300     update   = g_new0(SimpleSpiceUpdate, 1);
 301     drawable = &update->drawable;
 302
 303     bbox.left = x1;
 304     bbox.top = y1;
 305     bbox.right = x2;
 306     bbox.bottom = y2;
 307
 308     drawable->surface_id = surface_id;
 309
 310     drawable->bbox            = bbox;
 311     drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
 312     drawable->effect          = QXL_EFFECT_OPAQUE;
 313     simple_set_release_info(&drawable->release_info, (intptr_t)update);
 314     drawable->type            = QXL_DRAW_BLACKNESS;
 315     drawable->surfaces_dest[0] = -1;
 316     drawable->surfaces_dest[1] = -1;
 317     drawable->surfaces_dest[2] = -1;
 318
 319     set_cmd(&update->ext, QXL_CMD_DRAW, (intptr_t)drawable);
 320
 321     push_command(spice_screen, &update->ext);
 322 }
 323
 324 static void
 325 create_primary_surface(SpiceScreen *spice_screen, uint32_t width,
 326                        uint32_t height)
 327 {
 328     QXLWorker *qxl_worker = spice_screen->qxl_worker;
 329     QXLDevSurfaceCreate surface = { 0, };
 330
 331     g_assert(height <= MAX_HEIGHT);
 332     g_assert(width <= MAX_WIDTH);
 333     g_assert(height > 0);
 334     g_assert(width > 0);
 335
 336     surface.format     = SPICE_SURFACE_FMT_32_xRGB;
 337     surface.width      = spice_screen->primary_width = width;
 338     surface.height     = spice_screen->primary_height = height;
 339     surface.stride     = -width * 4; /* negative? */
 340     surface.mouse_mode = TRUE; /* unused by red_worker */
 341     surface.flags      = 0;
 342     surface.type       = 0;    /* unused by red_worker */
 343     surface.position   = 0;    /* unused by red_worker */
 344     surface.mem        = (uint64_t)&spice_screen->primary_surface;
 345     surface.group_id   = MEM_SLOT_GROUP_ID;
 346
 347     spice_screen->width = width;
 348     spice_screen->height = height;
 349
 350     qxl_worker->create_primary_surface(qxl_worker, 0, &surface);
 351 }
 352
 353 QXLDevMemSlot slot = {
 354     .slot_group_id = MEM_SLOT_GROUP_ID,
 355     .slot_id = 0,
 356     .generation = 0,
 357     .virt_start = 0,
 358     .virt_end = ~0,
 359     .addr_delta = 0,
 360     .qxl_ram_size = ~0,
 361 };
 362
 363 static void
 364 attache_worker(QXLInstance *qin, QXLWorker *_qxl_worker)
 365 {
 366     SpiceScreen *spice_screen = SPICE_CONTAINEROF(qin, SpiceScreen, qxl_instance);
 367
 368     if (spice_screen->qxl_worker) {
 369         g_assert_not_reached();
 370     }
 371
 372     spice_screen->qxl_worker = _qxl_worker;
 373     spice_screen->qxl_worker->add_memslot(spice_screen->qxl_worker, &slot);
 374     create_primary_surface(spice_screen, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 375     spice_screen->qxl_worker->start(spice_screen->qxl_worker);
 376 }
 377
 378 static void
 379 set_compression_level(QXLInstance *qin, int level)
 380 {
 381     /* not used */
 382 }
 383
 384 static void
 385 set_mm_time(QXLInstance *qin, uint32_t mm_time)
 386 {
 387     /* not used */
 388 }
 389
 390 static void
 391 get_init_info(QXLInstance *qin, QXLDevInitInfo *info)
 392 {
 393     memset(info, 0, sizeof(*info));
 394     info->num_memslots = 1;
 395     info->num_memslots_groups = 1;
 396     info->memslot_id_bits = 1;
 397     info->memslot_gen_bits = 1;
 398     info->n_surfaces = 1;
 399 }
 400
 401 /* called from spice_server thread (i.e. red_worker thread) */
 402 static int
 403 get_command(QXLInstance *qin, struct QXLCommandExt *ext)
 404 {
 405     SpiceScreen *spice_screen = SPICE_CONTAINEROF(qin, SpiceScreen, qxl_instance);
 406     int res = FALSE;
 407
 408     g_mutex_lock(spice_screen->command_mutex);
 409
 410     if ((spice_screen->commands_end - spice_screen->commands_start) == 0) {
 411         res = FALSE;
 412         goto ret;
 413     }
 414
 415     *ext = *spice_screen->commands[spice_screen->commands_start % COMMANDS_SIZE];
 416     g_assert(spice_screen->commands_start < spice_screen->commands_end);
 417     spice_screen->commands_start++;
 418     g_cond_signal(spice_screen->command_cond);
 419
 420     res = TRUE;
 421
 422 ret:
 423     g_mutex_unlock(spice_screen->command_mutex);
 424     return res;
 425 }
 426
 427 static int
 428 req_cmd_notification(QXLInstance *qin)
 429 {
 430     //SpiceScreen *spice_screen = SPICE_CONTAINEROF(qin, SpiceScreen, qxl_instance);
 431     //spice_screen->core->timer_start(spice_screen->wakeup_timer, spice_screen->wakeup_ms);
 432
 433     return TRUE;
 434 }
 435
 436 static void
 437 release_resource(QXLInstance *qin, struct QXLReleaseInfoExt release_info)
 438 {
 439     QXLCommandExt *ext = (QXLCommandExt*)(unsigned long)release_info.info->id;
 440
 441     g_assert(release_info.group_id == MEM_SLOT_GROUP_ID);
 442     switch (ext->cmd.type) {
 443         case QXL_CMD_DRAW:
 444             spice_screen_destroy_update((void*)ext);
 445             break;
 446         case QXL_CMD_SURFACE:
 447             free(ext);
 448             break;
 449         case QXL_CMD_CURSOR: {
 450             QXLCursorCmd *cmd = (QXLCursorCmd *)(unsigned long)ext->cmd.data;
 451             if (cmd->type == QXL_CURSOR_SET) {
 452                 free(cmd);
 453             }
 454             free(ext);
 455             break;
 456         }
 457         default:
 458             abort();
 459     }
 460 }
 461
 462 #define CURSOR_WIDTH 8
 463 #define CURSOR_HEIGHT 16
 464
 465 static struct {
 466     QXLCursor cursor;
 467     uint8_t data[CURSOR_WIDTH * CURSOR_HEIGHT * 4]; // 32bit per pixel
 468 } cursor;
 469
 470 static void
 471 cursor_init()
 472 {
 473     cursor.cursor.header.unique = 0;
 474     cursor.cursor.header.type = SPICE_CURSOR_TYPE_COLOR32;
 475     cursor.cursor.header.width = CURSOR_WIDTH;
 476     cursor.cursor.header.height = CURSOR_HEIGHT;
 477     cursor.cursor.header.hot_spot_x = 0;
 478     cursor.cursor.header.hot_spot_y = 0;
 479     cursor.cursor.data_size = CURSOR_WIDTH * CURSOR_HEIGHT * 4;
 480
 481     // X drivers addes it to the cursor size because it could be
 482     // cursor data information or another cursor related stuffs.
 483     // Otherwise, the code will break in client/cursor.cpp side,
 484     // that expect the data_size plus cursor information.
 485     // Blame cursor protocol for this. :-)
 486     cursor.cursor.data_size += 128;
 487     cursor.cursor.chunk.data_size = cursor.cursor.data_size;
 488     cursor.cursor.chunk.prev_chunk = cursor.cursor.chunk.next_chunk = 0;
 489 }
 490
 491 static int
 492 get_cursor_command(QXLInstance *qin, struct QXLCommandExt *ext)
 493 {
 494     SpiceScreen *spice_screen = SPICE_CONTAINEROF(qin, SpiceScreen, qxl_instance);
 495     static int set = 1;
 496     static int x = 0, y = 0;
 497     QXLCursorCmd *cursor_cmd;
 498     QXLCommandExt *cmd;
 499
 500     if (!spice_screen->cursor_notify) {
 501         return FALSE;
 502     }
 503
 504     spice_screen->cursor_notify--;
 505     cmd = calloc(sizeof(QXLCommandExt), 1);
 506     cursor_cmd = calloc(sizeof(QXLCursorCmd), 1);
 507
 508     cursor_cmd->release_info.id = (unsigned long)cmd;
 509
 510     if (set) {
 511         cursor_cmd->type = QXL_CURSOR_SET;
 512         cursor_cmd->u.set.position.x = 0;
 513         cursor_cmd->u.set.position.y = 0;
 514         cursor_cmd->u.set.visible = TRUE;
 515         cursor_cmd->u.set.shape = (unsigned long)&cursor;
 516         // white rect as cursor
 517         memset(cursor.data, 255, sizeof(cursor.data));
 518         set = 0;
 519     } else {
 520         cursor_cmd->type = QXL_CURSOR_MOVE;
 521         cursor_cmd->u.position.x = x++ % spice_screen->primary_width;
 522         cursor_cmd->u.position.y = y++ % spice_screen->primary_height;
 523     }
 524
 525     cmd->cmd.data = (unsigned long)cursor_cmd;
 526     cmd->cmd.type = QXL_CMD_CURSOR;
 527     cmd->group_id = MEM_SLOT_GROUP_ID;
 528     cmd->flags    = 0;
 529     *ext = *cmd;
 530
 531     return TRUE;
 532 }
 533
 534 static int
 535 req_cursor_notification(QXLInstance *qin)
 536 {
 537     /* not used */
 538
 539     return TRUE;
 540 }
 541
 542 static void
 543 notify_update(QXLInstance *qin, uint32_t update_id)
 544 {
 545     /* not used */
 546 }
 547
 548 static int
 549 flush_resources(QXLInstance *qin)
 550 {
 551     /* not used */
 552
 553     return TRUE;
 554 }
 555
 556 static int
 557 client_monitors_config(QXLInstance *qin, VDAgentMonitorsConfig *monitors_config)
 558 {
 559     /* not used */
 560
 561     return 0;
 562 }
 563
 564 static void
 565 set_client_capabilities(QXLInstance *qin, uint8_t client_present,
 566                         uint8_t caps[58])
 567 {
 568     SpiceScreen *spice_screen = SPICE_CONTAINEROF(qin, SpiceScreen, qxl_instance);
 569
 570     DPRINTF(1, "present %d caps %d", client_present, caps[0]);
 571
 572     if (spice_screen->on_client_connected && client_present) {
 573         spice_screen->on_client_connected(spice_screen);
 574     }
 575     if (spice_screen->on_client_disconnected && !client_present) {
 576         spice_screen->on_client_disconnected(spice_screen);
 577     }
 578 }
 579
 580 static int client_count = 0;
 581
 582 static void
 583 client_connected(SpiceScreen *spice_screen)
 584 {
 585     client_count++;
 586
 587     DPRINTF(1, "client_count = %d", client_count);
 588 }
 589
 590 static void
 591 client_disconnected(SpiceScreen *spice_screen)
 592 {
 593     if (client_count > 0) {
 594         client_count--;
 595         DPRINTF(1, "client_count = %d", client_count);
 596         exit(0); // fixme: cleanup?
 597     }
 598 }
 599
 600 static void
 601 do_conn_timeout(void *opaque)
 602 {
 603     // SpiceScreen *spice_screen = opaque;
 604
 605     if (client_count <= 0) {
 606         printf("connection timeout - stopping server\n");
 607         exit (0); // fixme: cleanup?
 608     }
 609 }
 610
 611 QXLInterface display_sif = {
 612     .base = {
 613         .type = SPICE_INTERFACE_QXL,
 614         .description = "spiceterm display server",
 615         .major_version = SPICE_INTERFACE_QXL_MAJOR,
 616         .minor_version = SPICE_INTERFACE_QXL_MINOR
 617     },
 618     .attache_worker = attache_worker,
 619     .set_compression_level = set_compression_level,
 620     .set_mm_time = set_mm_time,
 621     .get_init_info = get_init_info,
 622
 623     /* the callbacks below are called from spice server thread context */
 624     .get_command = get_command,
 625     .req_cmd_notification = req_cmd_notification,
 626     .release_resource = release_resource,
 627     .get_cursor_command = get_cursor_command,
 628     .req_cursor_notification = req_cursor_notification,
 629     .notify_update = notify_update,
 630     .flush_resources = flush_resources,
 631     .client_monitors_config = client_monitors_config,
 632     .set_client_capabilities = set_client_capabilities,
 633 };
 634
 635
 636 void
 637 spice_screen_draw_char(SpiceScreen *spice_screen, int x, int y, gunichar2 ch,
 638                        TextAttributes attrib)
 639 {
 640     int fg, bg;
 641
 642     int invers;
 643     if (attrib.invers) {
 644         invers = attrib.selected ? 0 : 1;
 645     } else {
 646         invers = attrib.selected ? 1 : 0;
 647     }
 648
 649     if (invers) {
 650         bg = attrib.fgcol;
 651         fg = attrib.bgcol;
 652     } else {
 653         bg = attrib.bgcol;
 654         fg = attrib.fgcol;
 655     }
 656
 657     if (attrib.bold) {
 658         fg += 8;
 659     }
 660
 661     // unsuported attributes = (attrib.blink || attrib.unvisible)
 662
 663     int c = vt_fontmap[ch];
 664
 665     SimpleSpiceUpdate *update;
 666     update = spice_screen_draw_char_cmd(spice_screen, x, y, c, fg, bg, attrib.uline);
 667     push_command(spice_screen, &update->ext);
 668 }
 669
 670 SpiceScreen *
 671 spice_screen_new(SpiceCoreInterface *core, guint timeout)
 672 {
 673     int port = 5912;
 674     SpiceScreen *spice_screen = g_new0(SpiceScreen, 1);
 675     SpiceServer* server = spice_server_new();
 676
 677     spice_screen->command_cond = g_cond_new();
 678     spice_screen->command_mutex = g_mutex_new();
 679
 680     spice_screen->on_client_connected = client_connected,
 681     spice_screen->on_client_disconnected = client_disconnected,
 682
 683     spice_screen->qxl_instance.base.sif = &display_sif.base;
 684     spice_screen->qxl_instance.id = 0;
 685
 686     spice_screen->core = core;
 687     spice_screen->server = server;
 688
 689     spice_screen->cursor_notify = NOTIFY_CURSOR_BATCH;
 690
 691     printf("listening on port %d (unsecure)\n", port);
 692
 693     spice_server_set_port(server, port);
 694     spice_server_set_noauth(server);
 695
 696     int res = spice_server_init(server, core);
 697     if (res != 0) {
 698         g_error("spice_server_init failed, res = %d\n", res);
 699     }
 700
 701     cursor_init();
 702
 703     spice_screen->conn_timeout_timer = core->timer_add(do_conn_timeout, spice_screen);
 704     spice_screen->core->timer_start(spice_screen->conn_timeout_timer, timeout*1000);
 705
 706     spice_server_add_interface(spice_screen->server, &spice_screen->qxl_instance.base);
 707
 708     return spice_screen;
 709 }