[qemu.git] / ui / vnc-enc-hextile-template.h

#define CONCAT_I(a, b) a ## b
#define CONCAT(a, b) CONCAT_I(a, b)
#define pixel_t CONCAT(uint, CONCAT(BPP, _t))
#ifdef GENERIC
#define NAME CONCAT(generic_, BPP)
#else
#define NAME BPP
#endif

static void CONCAT(send_hextile_tile_, NAME)(VncState *vs,
                                             int x, int y, int w, int h,
                                             void *last_bg_,
                                             void *last_fg_,
                                             int *has_bg, int *has_fg)
{
    VncDisplay *vd = vs->vd;
    uint8_t *row = vnc_server_fb_ptr(vd, x, y);
    pixel_t *irow = (pixel_t *)row;
    int j, i;
    pixel_t *last_bg = (pixel_t *)last_bg_;
    pixel_t *last_fg = (pixel_t *)last_fg_;
    pixel_t bg = 0;
    pixel_t fg = 0;
    int n_colors = 0;
    int bg_count = 0;
    int fg_count = 0;
    int flags = 0;
    uint8_t data[(vs->client_pf.bytes_per_pixel + 2) * 16 * 16];
    int n_data = 0;
    int n_subtiles = 0;

    for (j = 0; j < h; j++) {
	for (i = 0; i < w; i++) {
	    switch (n_colors) {
	    case 0:
		bg = irow[i];
		n_colors = 1;
		break;
	    case 1:
		if (irow[i] != bg) {
		    fg = irow[i];
		    n_colors = 2;
		}
		break;
	    case 2:
		if (irow[i] != bg && irow[i] != fg) {
		    n_colors = 3;
		} else {
		    if (irow[i] == bg)
			bg_count++;
		    else if (irow[i] == fg)
			fg_count++;
		}
		break;
	    default:
		break;
	    }
	}
	if (n_colors > 2)
	    break;
	irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
    }

    if (n_colors > 1 && fg_count > bg_count) {
	pixel_t tmp = fg;
	fg = bg;
	bg = tmp;
    }

    if (!*has_bg || *last_bg != bg) {
	flags |= 0x02;
	*has_bg = 1;
	*last_bg = bg;
    }

    if (n_colors < 3 && (!*has_fg || *last_fg != fg)) {
	flags |= 0x04;
	*has_fg = 1;
	*last_fg = fg;
    }

    switch (n_colors) {
    case 1:
	n_data = 0;
	break;
    case 2:
	flags |= 0x08;

	irow = (pixel_t *)row;

	for (j = 0; j < h; j++) {
	    int min_x = -1;
	    for (i = 0; i < w; i++) {
		if (irow[i] == fg) {
		    if (min_x == -1)
			min_x = i;
		} else if (min_x != -1) {
		    hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
		    n_data += 2;
		    n_subtiles++;
		    min_x = -1;
		}
	    }
	    if (min_x != -1) {
		hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
		n_data += 2;
		n_subtiles++;
	    }
	    irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
	}
	break;
    case 3:
	flags |= 0x18;

	irow = (pixel_t *)row;

	if (!*has_bg || *last_bg != bg)
	    flags |= 0x02;

	for (j = 0; j < h; j++) {
	    int has_color = 0;
	    int min_x = -1;
	    pixel_t color = 0; /* shut up gcc */

	    for (i = 0; i < w; i++) {
		if (!has_color) {
		    if (irow[i] == bg)
			continue;
		    color = irow[i];
		    min_x = i;
		    has_color = 1;
		} else if (irow[i] != color) {
		    has_color = 0;
#ifdef GENERIC
                    vnc_convert_pixel(vs, data + n_data, color);
                    n_data += vs->client_pf.bytes_per_pixel;
#else
		    memcpy(data + n_data, &color, sizeof(color));
                    n_data += sizeof(pixel_t);
#endif
		    hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
		    n_data += 2;
		    n_subtiles++;

		    min_x = -1;
		    if (irow[i] != bg) {
			color = irow[i];
			min_x = i;
			has_color = 1;
		    }
		}
	    }
	    if (has_color) {
#ifdef GENERIC
                vnc_convert_pixel(vs, data + n_data, color);
                n_data += vs->client_pf.bytes_per_pixel;
#else
                memcpy(data + n_data, &color, sizeof(color));
                n_data += sizeof(pixel_t);
#endif
		hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
		n_data += 2;
		n_subtiles++;
	    }
	    irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
	}

	/* A SubrectsColoured subtile invalidates the foreground color */
	*has_fg = 0;
	if (n_data > (w * h * sizeof(pixel_t))) {
	    n_colors = 4;
	    flags = 0x01;
	    *has_bg = 0;

	    /* we really don't have to invalidate either the bg or fg
	       but we've lost the old values.  oh well. */
	}
        break;
    default:
	break;
    }

    if (n_colors > 3) {
	flags = 0x01;
	*has_fg = 0;
	*has_bg = 0;
	n_colors = 4;
    }

    vnc_write_u8(vs, flags);
    if (n_colors < 4) {
	if (flags & 0x02)
	    vs->write_pixels(vs, last_bg, sizeof(pixel_t));
	if (flags & 0x04)
	    vs->write_pixels(vs, last_fg, sizeof(pixel_t));
	if (n_subtiles) {
	    vnc_write_u8(vs, n_subtiles);
	    vnc_write(vs, data, n_data);
	}
    } else {
	for (j = 0; j < h; j++) {
	    vs->write_pixels(vs, row, w * 4);
	    row += vnc_server_fb_stride(vd);
	}
    }
}

#undef NAME
#undef pixel_t
#undef CONCAT_I
#undef CONCAT
Commit	Line	Data
24236869 FB	1	#define CONCAT_I(a, b) a ## b
	2	#define CONCAT(a, b) CONCAT_I(a, b)
	3	#define pixel_t CONCAT(uint, CONCAT(BPP, _t))
3512779a	4	#ifdef GENERIC
7eac3a87	5	#define NAME CONCAT(generic_, BPP)
3512779a FB	6	#else
	7	#define NAME BPP
	8	#endif
	9
	10	static void CONCAT(send_hextile_tile_, NAME)(VncState *vs,
	11	int x, int y, int w, int h,
7eac3a87 AL	12	void *last_bg_,
7eac3a87 AL	13	void *last_fg_,
3512779a	14	int has_bg, int has_fg)
24236869	15	{
1fc62412	16	VncDisplay *vd = vs->vd;
9f64916d	17	uint8_t *row = vnc_server_fb_ptr(vd, x, y);
24236869 FB	18	pixel_t irow = (pixel_t )row;
24236869 FB	19	int j, i;
7eac3a87 AL	20	pixel_t last_bg = (pixel_t )last_bg_;
7eac3a87 AL	21	pixel_t last_fg = (pixel_t )last_fg_;
24236869 FB	22	pixel_t bg = 0;
	23	pixel_t fg = 0;
	24	int n_colors = 0;
	25	int bg_count = 0;
	26	int fg_count = 0;
	27	int flags = 0;
9f64916d	28	uint8_t data[(vs->client_pf.bytes_per_pixel + 2) * 16 * 16];
24236869 FB	29	int n_data = 0;
	30	int n_subtiles = 0;
	31
	32	for (j = 0; j < h; j++) {
	33	for (i = 0; i < w; i++) {
	34	switch (n_colors) {
	35	case 0:
	36	bg = irow[i];
	37	n_colors = 1;
	38	break;
	39	case 1:
	40	if (irow[i] != bg) {
	41	fg = irow[i];
	42	n_colors = 2;
	43	}
	44	break;
	45	case 2:
	46	if (irow[i] != bg && irow[i] != fg) {
	47	n_colors = 3;
	48	} else {
	49	if (irow[i] == bg)
	50	bg_count++;
	51	else if (irow[i] == fg)
	52	fg_count++;
	53	}
	54	break;
	55	default:
	56	break;
	57	}
	58	}
	59	if (n_colors > 2)
	60	break;
9f64916d	61	irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
24236869 FB	62	}
	63
	64	if (n_colors > 1 && fg_count > bg_count) {
	65	pixel_t tmp = fg;
	66	fg = bg;
	67	bg = tmp;
	68	}
	69
	70	if (!has_bg \|\| last_bg != bg) {
	71	flags \|= 0x02;
	72	*has_bg = 1;
	73	*last_bg = bg;
	74	}
	75
02c2b87f	76	if (n_colors < 3 && (!has_fg \|\| last_fg != fg)) {
24236869 FB	77	flags \|= 0x04;
	78	*has_fg = 1;
	79	*last_fg = fg;
	80	}
	81
	82	switch (n_colors) {
	83	case 1:
	84	n_data = 0;
	85	break;
	86	case 2:
	87	flags \|= 0x08;
	88
	89	irow = (pixel_t *)row;
5fafdf24	90
24236869 FB	91	for (j = 0; j < h; j++) {
	92	int min_x = -1;
	93	for (i = 0; i < w; i++) {
	94	if (irow[i] == fg) {
	95	if (min_x == -1)
	96	min_x = i;
	97	} else if (min_x != -1) {
	98	hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
	99	n_data += 2;
	100	n_subtiles++;
	101	min_x = -1;
	102	}
	103	}
	104	if (min_x != -1) {
	105	hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
	106	n_data += 2;
	107	n_subtiles++;
	108	}
9f64916d	109	irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
24236869 FB	110	}
	111	break;
	112	case 3:
	113	flags \|= 0x18;
	114
	115	irow = (pixel_t *)row;
	116
	117	if (!has_bg \|\| last_bg != bg)
	118	flags \|= 0x02;
	119
	120	for (j = 0; j < h; j++) {
	121	int has_color = 0;
	122	int min_x = -1;
92190c64	123	pixel_t color = 0; /* shut up gcc */
24236869 FB	124
	125	for (i = 0; i < w; i++) {
	126	if (!has_color) {
	127	if (irow[i] == bg)
	128	continue;
	129	color = irow[i];
	130	min_x = i;
	131	has_color = 1;
	132	} else if (irow[i] != color) {
	133	has_color = 0;
3512779a FB	134	#ifdef GENERIC
3512779a FB	135	vnc_convert_pixel(vs, data + n_data, color);
9f64916d	136	n_data += vs->client_pf.bytes_per_pixel;
3512779a	137	#else
24236869	138	memcpy(data + n_data, &color, sizeof(color));
3512779a FB	139	n_data += sizeof(pixel_t);
	140	#endif
	141	hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
	142	n_data += 2;
24236869 FB	143	n_subtiles++;
	144
	145	min_x = -1;
	146	if (irow[i] != bg) {
	147	color = irow[i];
	148	min_x = i;
	149	has_color = 1;
	150	}
	151	}
	152	}
	153	if (has_color) {
3512779a FB	154	#ifdef GENERIC
3512779a FB	155	vnc_convert_pixel(vs, data + n_data, color);
9f64916d	156	n_data += vs->client_pf.bytes_per_pixel;
3512779a FB	157	#else
	158	memcpy(data + n_data, &color, sizeof(color));
	159	n_data += sizeof(pixel_t);
	160	#endif
	161	hextile_enc_cord(data + n_data, min_x, j, i - min_x, 1);
	162	n_data += 2;
24236869 FB	163	n_subtiles++;
24236869 FB	164	}
9f64916d	165	irow += vnc_server_fb_stride(vd) / sizeof(pixel_t);
24236869 FB	166	}
24236869 FB	167
18cb1d85 AL	168	/* A SubrectsColoured subtile invalidates the foreground color */
18cb1d85 AL	169	*has_fg = 0;
24236869 FB	170	if (n_data > (w * h * sizeof(pixel_t))) {
	171	n_colors = 4;
	172	flags = 0x01;
	173	*has_bg = 0;
	174
	175	/* we really don't have to invalidate either the bg or fg
	176	but we've lost the old values. oh well. */
	177	}
0ea5c0cd	178	break;
24236869 FB	179	default:
	180	break;
	181	}
	182
	183	if (n_colors > 3) {
	184	flags = 0x01;
	185	*has_fg = 0;
	186	*has_bg = 0;
	187	n_colors = 4;
	188	}
	189
	190	vnc_write_u8(vs, flags);
	191	if (n_colors < 4) {
	192	if (flags & 0x02)
9f64916d	193	vs->write_pixels(vs, last_bg, sizeof(pixel_t));
24236869	194	if (flags & 0x04)
9f64916d	195	vs->write_pixels(vs, last_fg, sizeof(pixel_t));
24236869 FB	196	if (n_subtiles) {
	197	vnc_write_u8(vs, n_subtiles);
	198	vnc_write(vs, data, n_data);
	199	}
	200	} else {
	201	for (j = 0; j < h; j++) {
9f64916d GH	202	vs->write_pixels(vs, row, w * 4);
9f64916d GH	203	row += vnc_server_fb_stride(vd);
24236869 FB	204	}
	205	}
	206	}
	207
3512779a	208	#undef NAME
24236869 FB	209	#undef pixel_t
	210	#undef CONCAT_I
	211	#undef CONCAT