#include <sys/types.h>
#include <getopt.h>
+#include "glyphs.h"
#include <spice.h>
+#include <spice/enums.h>
#include <spice/macros.h>
#include <spice/qxl_dev.h>
#include "test_display_base.h"
-//#include "red_channel.h"
#define MEM_SLOT_GROUP_ID 0
#define NOTIFY_DISPLAY_BATCH (SINGLE_PART/2)
#define NOTIFY_CURSOR_BATCH 10
+/* these colours are from linux kernel drivers/char/vt.c */
+/* the default colour table, for VGA+ colour systems */
+int default_red[] = {0x00,0xaa,0x00,0xaa,0x00,0xaa,0x00,0xaa,
+ 0x55,0xff,0x55,0xff,0x55,0xff,0x55,0xff};
+int default_grn[] = {0x00,0x00,0xaa,0x55,0x00,0x00,0xaa,0xaa,
+ 0x55,0x55,0xff,0xff,0x55,0x55,0xff,0xff};
+int default_blu[] = {0x00,0x00,0x00,0x00,0xaa,0xaa,0xaa,0xaa,
+ 0x55,0x55,0x55,0x55,0xff,0xff,0xff,0xff};
+
/* Parts cribbed from spice-display.h/.c/qxl.c */
typedef struct SimpleSpiceUpdate {
uint8_t *bitmap;
} SimpleSpiceUpdate;
-typedef struct SimpleSurfaceCmd {
- QXLCommandExt ext; // first
- QXLSurfaceCmd surface_cmd;
-} SimpleSurfaceCmd;
-
static void test_spice_destroy_update(SimpleSpiceUpdate *update)
{
if (!update) {
uint8_t *ptr = (uint8_t*)update->drawable.clip.data;
free(ptr);
}
- free(update->bitmap);
- free(update);
+ g_free(update->bitmap);
+ g_free(update);
}
#define DEFAULT_WIDTH 640
static int color = -1;
static int c_i = 0;
-/* Used for automated tests */
-static int control = 3; //used to know when we can take a screenshot
-static int rects = 16; //number of rects that will be draw
-static int has_automated_tests = 0; //automated test flag
-
__attribute__((noreturn))
static void sigchld_handler(int signal_num) // wait for the child process and exit
{
exit(0);
}
-static void regression_test(void)
-{
- pid_t pid;
-
- if (--rects != 0) {
- return;
- }
-
- rects = 16;
-
- if (--control != 0) {
- return;
- }
-
- pid = fork();
- if (pid == 0) {
- char buf[PATH_MAX];
- char *envp[] = {buf, NULL};
-
- snprintf(buf, sizeof(buf), "PATH=%s", getenv("PATH"));
- execve("regression_test.py", NULL, envp);
- } else if (pid > 0) {
- return;
- }
-}
-
static void set_cmd(QXLCommandExt *ext, uint32_t type, QXLPHYSICAL data)
{
ext->cmd.type = type;
//info->group_id = MEM_SLOT_GROUP_ID;
}
-typedef struct Path {
- int t;
- int min_t;
- int max_t;
-} Path;
-
-static void path_init(Path *path, int min, int max)
-{
- path->t = min;
- path->min_t = min;
- path->max_t = max;
-}
-
-static void path_progress(Path *path)
-{
- path->t = (path->t+1)% (path->max_t - path->min_t) + path->min_t;
-}
-
-Path path;
-
-static void draw_pos(Test *test, int t, int *x, int *y)
-{
-#ifdef CIRCLE
- *y = test->primary_height/2 + (test->primary_height/3)*cos(t*2*M_PI/angle_parts);
- *x = test->primary_width/2 + (test->primary_width/3)*sin(t*2*M_PI/angle_parts);
-#else
- *y = test->primary_height*(t % SINGLE_PART)/SINGLE_PART;
- *x = ((test->primary_width/SINGLE_PART)*(t / SINGLE_PART)) % test->primary_width;
-#endif
-}
-
-/* bitmap and rects are freed, so they must be allocated with malloc */
+/* bitmap are freed, so they must be allocated with g_malloc */
SimpleSpiceUpdate *test_spice_create_update_from_bitmap(uint32_t surface_id,
QXLRect bbox,
- uint8_t *bitmap,
- uint32_t num_clip_rects,
- QXLRect *clip_rects)
+ uint8_t *bitmap)
{
SimpleSpiceUpdate *update;
QXLDrawable *drawable;
bh = bbox.bottom - bbox.top;
bw = bbox.right - bbox.left;
- update = calloc(sizeof(*update), 1);
+ update = g_new0(SimpleSpiceUpdate, 1);
update->bitmap = bitmap;
drawable = &update->drawable;
image = &update->image;
drawable->surface_id = surface_id;
drawable->bbox = bbox;
- if (num_clip_rects == 0) {
- drawable->clip.type = SPICE_CLIP_TYPE_NONE;
- } else {
- QXLClipRects *cmd_clip;
-
- cmd_clip = calloc(sizeof(QXLClipRects) + num_clip_rects*sizeof(QXLRect), 1);
- cmd_clip->num_rects = num_clip_rects;
- cmd_clip->chunk.data_size = num_clip_rects*sizeof(QXLRect);
- cmd_clip->chunk.prev_chunk = cmd_clip->chunk.next_chunk = 0;
- memcpy(cmd_clip + 1, clip_rects, cmd_clip->chunk.data_size);
-
- drawable->clip.type = SPICE_CLIP_TYPE_RECTS;
- drawable->clip.data = (intptr_t)cmd_clip;
-
- free(clip_rects);
- }
+ drawable->clip.type = SPICE_CLIP_TYPE_NONE;
drawable->effect = QXL_EFFECT_OPAQUE;
simple_set_release_info(&drawable->release_info, (intptr_t)update);
drawable->type = QXL_DRAW_COPY;
return update;
}
-static SimpleSpiceUpdate *test_spice_create_update_solid(uint32_t surface_id, QXLRect bbox, uint32_t color)
-{
- uint8_t *bitmap;
- uint32_t *dst;
- uint32_t bw;
- uint32_t bh;
- int i;
-
- bw = bbox.right - bbox.left;
- bh = bbox.bottom - bbox.top;
-
- bitmap = malloc(bw * bh * 4);
- dst = (uint32_t *)bitmap;
-
- for (i = 0 ; i < bh * bw ; ++i, ++dst) {
- *dst = color;
- }
-
- return test_spice_create_update_from_bitmap(surface_id, bbox, bitmap, 0, NULL);
-}
-
-static SimpleSpiceUpdate *test_spice_create_update_draw(Test *test, uint32_t surface_id, int t)
+static SimpleSpiceUpdate *test_draw_char(Test *test, int x, int y, int c, int fg, int bg)
{
int top, left;
uint8_t *dst;
uint8_t *bitmap;
int bw, bh;
- int i;
+ int i, j;
QXLRect bbox;
- draw_pos(test, t, &left, &top);
- if ((t % angle_parts) == 0) {
- c_i++;
- }
-
- if (surface_id != 0) {
- color = (color + 1) % 2;
- } else {
- color = surface_id;
- }
+ left = x*8;
+ top = y*16;
+ // printf("DRAWCHAR %d %d %d\n", left, top, c);
+
unique++;
- bw = test->primary_width/SINGLE_PART;
- bh = 48;
+ bw = 8;
+ bh = 16;
- bitmap = dst = malloc(bw * bh * 4);
- //printf("allocated %p\n", dst);
+ bitmap = dst = g_malloc(bw * bh * 4);
- for (i = 0 ; i < bh * bw ; ++i, dst+=4) {
- *dst = (color+i % 255);
- *(dst+((1+c_i)%3)) = 255 - color;
- *(dst+((2+c_i)%3)) = (color * (color + i)) & 0xff;
- *(dst+((3+c_i)%3)) = 0;
- }
+ unsigned char *data = vt_font_data + c*16;
+ unsigned char d = *data;
- bbox.left = left; bbox.top = top;
- bbox.right = left + bw; bbox.bottom = top + bh;
- return test_spice_create_update_from_bitmap(surface_id, bbox, bitmap, 0, NULL);
-}
+ g_assert(fg >= 0 && fg < 16);
+ g_assert(bg >= 0 && bg < 16);
-static SimpleSpiceUpdate *test_spice_create_update_copy_bits(Test *test, uint32_t surface_id)
-{
- SimpleSpiceUpdate *update;
- QXLDrawable *drawable;
- int bw, bh;
- QXLRect bbox = {
- .left = 10,
- .top = 0,
- };
-
- update = calloc(sizeof(*update), 1);
- drawable = &update->drawable;
-
- bw = test->primary_width/SINGLE_PART;
- bh = 48;
- bbox.right = bbox.left + bw;
- bbox.bottom = bbox.top + bh;
- //printf("allocated %p, %p\n", update, update->bitmap);
-
- drawable->surface_id = surface_id;
+ unsigned char fgc_red = default_red[fg];
+ unsigned char fgc_blue = default_blu[fg];
+ unsigned char fgc_green = default_grn[fg];
+ unsigned char bgc_red = default_red[bg];
+ unsigned char bgc_blue = default_blu[bg];
+ unsigned char bgc_green = default_grn[bg];
- drawable->bbox = bbox;
- drawable->clip.type = SPICE_CLIP_TYPE_NONE;
- drawable->effect = QXL_EFFECT_OPAQUE;
- simple_set_release_info(&drawable->release_info, (intptr_t)update);
- drawable->type = QXL_COPY_BITS;
- drawable->surfaces_dest[0] = -1;
- drawable->surfaces_dest[1] = -1;
- drawable->surfaces_dest[2] = -1;
-
- drawable->u.copy_bits.src_pos.x = 0;
- drawable->u.copy_bits.src_pos.y = 0;
-
- set_cmd(&update->ext, QXL_CMD_DRAW, (intptr_t)drawable);
-
- return update;
-}
-
-static int format_to_bpp(int format)
-{
- switch (format) {
- case SPICE_SURFACE_FMT_8_A:
- return 1;
- case SPICE_SURFACE_FMT_16_555:
- case SPICE_SURFACE_FMT_16_565:
- return 2;
- case SPICE_SURFACE_FMT_32_xRGB:
- case SPICE_SURFACE_FMT_32_ARGB:
- return 4;
+ for (j = 0; j < 16; j++) {
+ for (i = 0; i < 8; i++) {
+ if ((i&7) == 0) {
+ d=*data;
+ data++;
+ }
+ if (d&0x80) {
+ *(dst) = fgc_blue;
+ *(dst+1) = fgc_green;
+ *(dst+2) = fgc_red;
+ *(dst+3) = 0;
+ } else {
+ *(dst) = bgc_blue;
+ *(dst+1) = bgc_green;
+ *(dst+2) = bgc_red;
+ *(dst+3) = 0;
+ }
+ d<<=1;
+ dst += 4;
+ }
}
- abort();
-}
-
-static SimpleSurfaceCmd *create_surface(int surface_id, int format, int width, int height, uint8_t *data)
-{
- SimpleSurfaceCmd *simple_cmd = calloc(sizeof(SimpleSurfaceCmd), 1);
- QXLSurfaceCmd *surface_cmd = &simple_cmd->surface_cmd;
- int bpp = format_to_bpp(format);
- set_cmd(&simple_cmd->ext, QXL_CMD_SURFACE, (intptr_t)surface_cmd);
- simple_set_release_info(&surface_cmd->release_info, (intptr_t)simple_cmd);
- surface_cmd->type = QXL_SURFACE_CMD_CREATE;
- surface_cmd->flags = 0; // ?
- surface_cmd->surface_id = surface_id;
- surface_cmd->u.surface_create.format = format;
- surface_cmd->u.surface_create.width = width;
- surface_cmd->u.surface_create.height = height;
- surface_cmd->u.surface_create.stride = -width * bpp;
- surface_cmd->u.surface_create.data = (intptr_t)data;
- return simple_cmd;
-}
-
-static SimpleSurfaceCmd *destroy_surface(int surface_id)
-{
- SimpleSurfaceCmd *simple_cmd = calloc(sizeof(SimpleSurfaceCmd), 1);
- QXLSurfaceCmd *surface_cmd = &simple_cmd->surface_cmd;
+ bbox.left = left; bbox.top = top;
+ bbox.right = left + bw; bbox.bottom = top + bh;
- set_cmd(&simple_cmd->ext, QXL_CMD_SURFACE, (intptr_t)surface_cmd);
- simple_set_release_info(&surface_cmd->release_info, (intptr_t)simple_cmd);
- surface_cmd->type = QXL_SURFACE_CMD_DESTROY;
- surface_cmd->flags = 0; // ?
- surface_cmd->surface_id = surface_id;
- return simple_cmd;
+ return test_spice_create_update_from_bitmap(0, bbox, bitmap);
}
static void create_primary_surface(Test *test, uint32_t width,
static void set_mm_time(QXLInstance *qin, uint32_t mm_time)
{
}
-
-// we now have a secondary surface
-#define MAX_SURFACE_NUM 2
-
static void get_init_info(QXLInstance *qin, QXLDevInitInfo *info)
{
memset(info, 0, sizeof(*info));
info->num_memslots_groups = 1;
info->memslot_id_bits = 1;
info->memslot_gen_bits = 1;
- info->n_surfaces = MAX_SURFACE_NUM;
+ info->n_surfaces = 1;
}
+
// We shall now have a ring of commands, so that we can update
// it from a separate thread - since get_command is called from
// the worker thread, and we need to sometimes do an update_area,
return TRUE;
}
-static void produce_command(Test *test)
-{
- Command *command;
- QXLWorker *qxl_worker = test->qxl_worker;
-
- g_assert(qxl_worker);
-
- if (test->has_secondary)
- test->target_surface = 1;
-
- if (!test->num_commands) {
- usleep(1000);
- return;
- }
-
- command = &test->commands[test->cmd_index];
- if (command->cb) {
- command->cb(test, command);
- }
- switch (command->command) {
- case SLEEP:
- printf("sleep %u seconds\n", command->sleep.secs);
- sleep(command->sleep.secs);
- break;
- case PATH_PROGRESS:
- path_progress(&path);
- break;
- case SIMPLE_UPDATE: {
- QXLRect rect = {
- .left = 0,
- .right = (test->target_surface == 0 ? test->primary_width : test->width),
- .top = 0,
- .bottom = (test->target_surface == 0 ? test->primary_height : test->height)
- };
- if (rect.right > 0 && rect.bottom > 0) {
- qxl_worker->update_area(qxl_worker, test->target_surface, &rect, NULL, 0, 1);
- }
- break;
- }
-
- /* Drawing commands, they all push a command to the command ring */
- case SIMPLE_COPY_BITS:
- case SIMPLE_DRAW_SOLID:
- case SIMPLE_DRAW_BITMAP:
- case SIMPLE_DRAW: {
- SimpleSpiceUpdate *update;
-
- if (has_automated_tests)
- {
- if (control == 0) {
- return;
- }
-
- regression_test();
- }
-
- switch (command->command) {
- case SIMPLE_COPY_BITS:
- update = test_spice_create_update_copy_bits(test, 0);
- break;
- case SIMPLE_DRAW:
- update = test_spice_create_update_draw(test, 0, path.t);
- break;
- case SIMPLE_DRAW_BITMAP:
- update = test_spice_create_update_from_bitmap(command->bitmap.surface_id,
- command->bitmap.bbox, command->bitmap.bitmap,
- command->bitmap.num_clip_rects, command->bitmap.clip_rects);
- break;
- case SIMPLE_DRAW_SOLID:
- update = test_spice_create_update_solid(command->solid.surface_id,
- command->solid.bbox, command->solid.color);
- break;
- }
- push_command(&update->ext);
- break;
- }
-
- case SIMPLE_CREATE_SURFACE: {
- SimpleSurfaceCmd *update;
- if (command->create_surface.data) {
- g_assert(command->create_surface.surface_id > 0);
- g_assert(command->create_surface.surface_id < MAX_SURFACE_NUM);
- g_assert(command->create_surface.surface_id == 1);
- update = create_surface(command->create_surface.surface_id,
- command->create_surface.format,
- command->create_surface.width,
- command->create_surface.height,
- command->create_surface.data);
- } else {
- update = create_surface(test->target_surface, SPICE_SURFACE_FMT_32_xRGB,
- SURF_WIDTH, SURF_HEIGHT,
- test->secondary_surface);
- }
- push_command(&update->ext);
- test->has_secondary = 1;
- break;
- }
-
- case SIMPLE_DESTROY_SURFACE: {
- SimpleSurfaceCmd *update;
- test->has_secondary = 0;
- update = destroy_surface(test->target_surface);
- test->target_surface = 0;
- push_command(&update->ext);
- break;
- }
-
- case DESTROY_PRIMARY:
- qxl_worker->destroy_primary_surface(qxl_worker, 0);
- break;
-
- case CREATE_PRIMARY:
- create_primary_surface(test,
- command->create_primary.width, command->create_primary.height);
- break;
- }
- test->cmd_index = (test->cmd_index + 1) % test->num_commands;
-}
-
static int req_cmd_notification(QXLInstance *qin)
{
Test *test = SPICE_CONTAINEROF(qin, Test, qxl_instance);
- test->core->timer_start(test->wakeup_timer, test->wakeup_ms);
+ //test->core->timer_start(test->wakeup_timer, test->wakeup_ms);
return TRUE;
}
-static void do_wakeup(void *opaque)
-{
- Test *test = opaque;
- int notify;
-
- test->cursor_notify = NOTIFY_CURSOR_BATCH;
- for (notify = NOTIFY_DISPLAY_BATCH; notify > 0;--notify) {
- produce_command(test);
- }
-
- test->core->timer_start(test->wakeup_timer, test->wakeup_ms);
- test->qxl_worker->wakeup(test->qxl_worker);
-}
-
static void release_resource(QXLInstance *qin, struct QXLReleaseInfoExt release_info)
{
QXLCommandExt *ext = (QXLCommandExt*)(unsigned long)release_info.info->id;
}
}
+static int client_count = 0;
+
+static void client_connected(Test *test)
+{
+ printf("Client connected\n");
+ client_count++;
+}
+
+static void client_disconnected(Test *test)
+{
+
+ if (client_count > 0) {
+ client_count--;
+ printf("Client disconnected\n");
+ exit(0); // fixme: cleanup?
+ }
+}
+
+static void do_conn_timeout(void *opaque)
+{
+ Test *test = opaque;
+
+ if (client_count <= 0) {
+ printf("do_conn_timeout\n");
+ exit (0); // fixme: cleanup?
+ }
+}
+
+
QXLInterface display_sif = {
.base = {
.type = SPICE_INTERFACE_QXL,
static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
{
- printf("%s: %d\n", __func__, len);
+// printf("%s: %d\n", __func__, len);
return len;
}
static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len)
{
- printf("%s: %d\n", __func__, len);
+// printf("%s: %d\n", __func__, len);
return 0;
}
static void vmc_state(SpiceCharDeviceInstance *sin, int connected)
{
- printf("%s: %d\n", __func__, connected);
+// printf("%s: %d\n", __func__, connected);
}
static SpiceCharDeviceInterface vdagent_sif = {
spice_server_add_interface(server, &vdagent_sin.base);
}
-void test_set_simple_command_list(Test *test, int *simple_commands, int num_commands)
+static int my_charcode = 65;
+static int my_posx = 0;
+static void kbd_push_key(SpiceKbdInstance *sin, uint8_t frag)
+{
+ Test *test = SPICE_CONTAINEROF(sin, Test, keyboard_sin);
+
+ printf("KEYCODE %u %p\n", frag, test);
+
+}
+
+void test_draw_update_char(Test *test, int x, int y, int c, TextAttributes attrib)
{
- int i;
+ int fg, bg;
- /* FIXME: leaks */
- test->commands = malloc(sizeof(*test->commands) * num_commands);
- memset(test->commands, 0, sizeof(*test->commands) * num_commands);
- test->num_commands = num_commands;
- for (i = 0 ; i < num_commands; ++i) {
- test->commands[i].command = simple_commands[i];
+ if (attrib.invers) {
+ bg = attrib.fgcol;
+ fg = attrib.bgcol;
+ } else {
+ bg = attrib.bgcol;
+ fg = attrib.fgcol;
+ }
+
+ if (attrib.bold) {
+ fg += 8;
}
+
+ // unsuported attributes = (attrib.blink || attrib.unvisible)
+
+ //if (attrib.uline) {
+ //rfbDrawLine (vt->screen, rx, ry + 14, rxe, ry + 14, fg);
+ //}
+
+ SimpleSpiceUpdate *update;
+ update = test_draw_char(test, x, y, c, fg, bg);
+ push_command(&update->ext);
+
+ test->qxl_worker->wakeup(test->qxl_worker);
}
-void test_set_command_list(Test *test, Command *commands, int num_commands)
+static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
{
- test->commands = commands;
- test->num_commands = num_commands;
+ return 0;
}
+static SpiceKbdInterface keyboard_sif = {
+ .base.type = SPICE_INTERFACE_KEYBOARD ,
+ .base.description = "spiceterm keyboard device",
+ .base.major_version = SPICE_INTERFACE_KEYBOARD_MAJOR,
+ .base.minor_version = SPICE_INTERFACE_KEYBOARD_MINOR,
+ .push_scan_freg = kbd_push_key,
+ .get_leds = kbd_get_leds,
+};
+
+void test_add_keyboard_interface(Test* test)
+{
+ spice_server_add_interface(test->server, &test->keyboard_sin.base);
+}
Test *test_new(SpiceCoreInterface *core)
{
Test *test = g_new0(Test, 1);
SpiceServer* server = spice_server_new();
+ test->on_client_connected = client_connected,
+ test->on_client_disconnected = client_disconnected,
+
test->qxl_instance.base.sif = &display_sif.base;
test->qxl_instance.id = 0;
+ test->keyboard_sin.base.sif = &keyboard_sif.base;
+
test->core = core;
test->server = server;
- test->wakeup_ms = 50;
+
test->cursor_notify = NOTIFY_CURSOR_BATCH;
// some common initialization for all display tests
printf("TESTER: listening on port %d (unsecure)\n", port);
}
cursor_init();
- path_init(&path, 0, angle_parts);
test->has_secondary = 0;
- test->wakeup_timer = core->timer_add(do_wakeup, test);
- return test;
-}
-void init_automated()
-{
- struct sigaction sa;
+ int timeout = 10; // max time to wait for client connection
+ test->conn_timeout_timer = core->timer_add(do_conn_timeout, test);
+ test->core->timer_start(test->conn_timeout_timer, timeout*1000);
- memset(&sa, 0, sizeof sa);
- sa.sa_handler = &sigchld_handler;
- sigaction(SIGCHLD, &sa, NULL);
+ return test;
}
+
__attribute__((noreturn))
void usage(const char *argv0, const int exitcode)
{
-#ifdef AUTOMATED_TESTS
- const char *autoopt=" [--automated-tests]";
-#else
- const char *autoopt="";
-#endif
- printf("usage: %s%s\n", argv0, autoopt);
+ printf("usage: %s\n", argv0);
exit(exitcode);
}
void spice_test_config_parse_args(int argc, char **argv)
{
struct option options[] = {
-#ifdef AUTOMATED_TESTS
- {"automated-tests", no_argument, &has_automated_tests, 1},
-#endif
+// {"automated-tests", no_argument, &has_automated_tests, 1},
{NULL, 0, NULL, 0},
};
int option_index;
printf("unknown argument '%s'\n", argv[optind]);
usage(argv[0], EXIT_FAILURE);
}
- if (has_automated_tests) {
- init_automated();
- }
return;
}
projects / spiceterm.git / blobdiff