2 * QEMU VNC display driver
4 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
5 * Copyright (C) 2006 Fabrice Bellard
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27 #include "qemu_socket.h"
29 #define VNC_REFRESH_INTERVAL (1000 / 30)
31 #include "vnc_keysym.h"
41 typedef struct VncState VncState
;
43 typedef int VncReadEvent(VncState
*vs
, char *data
, size_t len
);
45 typedef void VncWritePixels(VncState
*vs
, void *data
, int size
);
47 typedef void VncSendHextileTile(VncState
*vs
,
48 int x
, int y
, int w
, int h
,
51 int *has_bg
, int *has_fg
);
53 #define VNC_MAX_WIDTH 2048
54 #define VNC_MAX_HEIGHT 2048
55 #define VNC_DIRTY_WORDS (VNC_MAX_WIDTH / (16 * 32))
66 uint32_t dirty_row
[VNC_MAX_HEIGHT
][VNC_DIRTY_WORDS
];
68 int depth
; /* internal VNC frame buffer byte per pixel */
71 int has_pointer_type_change
;
78 kbd_layout_t
*kbd_layout
;
79 /* current output mode information */
80 VncWritePixels
*write_pixels
;
81 VncSendHextileTile
*send_hextile_tile
;
82 int pix_bpp
, pix_big_endian
;
83 int red_shift
, red_max
, red_shift1
;
84 int green_shift
, green_max
, green_shift1
;
85 int blue_shift
, blue_max
, blue_shift1
;
87 VncReadEvent
*read_handler
;
88 size_t read_handler_expect
;
90 uint8_t modifiers_state
[256];
94 1) Get the queue working for IO.
95 2) there is some weirdness when using the -S option (the screen is grey
96 and not totally invalidated
100 static void vnc_write(VncState
*vs
, const void *data
, size_t len
);
101 static void vnc_write_u32(VncState
*vs
, uint32_t value
);
102 static void vnc_write_s32(VncState
*vs
, int32_t value
);
103 static void vnc_write_u16(VncState
*vs
, uint16_t value
);
104 static void vnc_write_u8(VncState
*vs
, uint8_t value
);
105 static void vnc_flush(VncState
*vs
);
106 static void vnc_update_client(void *opaque
);
107 static void vnc_client_read(void *opaque
);
109 static inline void vnc_set_bit(uint32_t *d
, int k
)
111 d
[k
>> 5] |= 1 << (k
& 0x1f);
114 static inline void vnc_clear_bit(uint32_t *d
, int k
)
116 d
[k
>> 5] &= ~(1 << (k
& 0x1f));
119 static inline void vnc_set_bits(uint32_t *d
, int n
, int nb_words
)
129 d
[j
++] = (1 << n
) - 1;
134 static inline int vnc_get_bit(const uint32_t *d
, int k
)
136 return (d
[k
>> 5] >> (k
& 0x1f)) & 1;
139 static inline int vnc_and_bits(const uint32_t *d1
, const uint32_t *d2
,
143 for(i
= 0; i
< nb_words
; i
++) {
144 if ((d1
[i
] & d2
[i
]) != 0)
150 static void vnc_dpy_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
152 VncState
*vs
= ds
->opaque
;
158 for (i
= 0; i
< w
; i
+= 16)
159 vnc_set_bit(vs
->dirty_row
[y
], (x
+ i
) / 16);
162 static void vnc_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
,
165 vnc_write_u16(vs
, x
);
166 vnc_write_u16(vs
, y
);
167 vnc_write_u16(vs
, w
);
168 vnc_write_u16(vs
, h
);
170 vnc_write_s32(vs
, encoding
);
173 static void vnc_dpy_resize(DisplayState
*ds
, int w
, int h
)
176 VncState
*vs
= ds
->opaque
;
178 ds
->data
= realloc(ds
->data
, w
* h
* vs
->depth
);
179 vs
->old_data
= realloc(vs
->old_data
, w
* h
* vs
->depth
);
181 if (ds
->data
== NULL
|| vs
->old_data
== NULL
) {
182 fprintf(stderr
, "vnc: memory allocation failed\n");
186 ds
->depth
= vs
->depth
* 8;
187 size_changed
= ds
->width
!= w
|| ds
->height
!= h
;
190 ds
->linesize
= w
* vs
->depth
;
191 if (vs
->csock
!= -1 && vs
->has_resize
&& size_changed
) {
192 vnc_write_u8(vs
, 0); /* msg id */
194 vnc_write_u16(vs
, 1); /* number of rects */
195 vnc_framebuffer_update(vs
, 0, 0, ds
->width
, ds
->height
, -223);
197 vs
->width
= ds
->width
;
198 vs
->height
= ds
->height
;
203 static void vnc_write_pixels_copy(VncState
*vs
, void *pixels
, int size
)
205 vnc_write(vs
, pixels
, size
);
208 /* slowest but generic code. */
209 static void vnc_convert_pixel(VncState
*vs
, uint8_t *buf
, uint32_t v
)
211 unsigned int r
, g
, b
;
213 r
= (v
>> vs
->red_shift1
) & vs
->red_max
;
214 g
= (v
>> vs
->green_shift1
) & vs
->green_max
;
215 b
= (v
>> vs
->blue_shift1
) & vs
->blue_max
;
216 v
= (r
<< vs
->red_shift
) |
217 (g
<< vs
->green_shift
) |
218 (b
<< vs
->blue_shift
);
219 switch(vs
->pix_bpp
) {
224 if (vs
->pix_big_endian
) {
234 if (vs
->pix_big_endian
) {
249 static void vnc_write_pixels_generic(VncState
*vs
, void *pixels1
, int size
)
251 uint32_t *pixels
= pixels1
;
256 for(i
= 0; i
< n
; i
++) {
257 vnc_convert_pixel(vs
, buf
, pixels
[i
]);
258 vnc_write(vs
, buf
, vs
->pix_bpp
);
262 static void send_framebuffer_update_raw(VncState
*vs
, int x
, int y
, int w
, int h
)
267 vnc_framebuffer_update(vs
, x
, y
, w
, h
, 0);
269 row
= vs
->ds
->data
+ y
* vs
->ds
->linesize
+ x
* vs
->depth
;
270 for (i
= 0; i
< h
; i
++) {
271 vs
->write_pixels(vs
, row
, w
* vs
->depth
);
272 row
+= vs
->ds
->linesize
;
276 static void hextile_enc_cord(uint8_t *ptr
, int x
, int y
, int w
, int h
)
278 ptr
[0] = ((x
& 0x0F) << 4) | (y
& 0x0F);
279 ptr
[1] = (((w
- 1) & 0x0F) << 4) | ((h
- 1) & 0x0F);
283 #include "vnchextile.h"
287 #include "vnchextile.h"
291 #include "vnchextile.h"
296 #include "vnchextile.h"
300 static void send_framebuffer_update_hextile(VncState
*vs
, int x
, int y
, int w
, int h
)
304 uint32_t last_fg32
, last_bg32
;
306 vnc_framebuffer_update(vs
, x
, y
, w
, h
, 5);
309 for (j
= y
; j
< (y
+ h
); j
+= 16) {
310 for (i
= x
; i
< (x
+ w
); i
+= 16) {
311 vs
->send_hextile_tile(vs
, i
, j
,
312 MIN(16, x
+ w
- i
), MIN(16, y
+ h
- j
),
313 &last_bg32
, &last_fg32
, &has_bg
, &has_fg
);
318 static void send_framebuffer_update(VncState
*vs
, int x
, int y
, int w
, int h
)
321 send_framebuffer_update_hextile(vs
, x
, y
, w
, h
);
323 send_framebuffer_update_raw(vs
, x
, y
, w
, h
);
326 static void vnc_copy(DisplayState
*ds
, int src_x
, int src_y
, int dst_x
, int dst_y
, int w
, int h
)
333 int pitch
= ds
->linesize
;
334 VncState
*vs
= ds
->opaque
;
336 vnc_update_client(vs
);
343 src
= (ds
->linesize
* (src_y
+ y
) + vs
->depth
* src_x
);
344 dst
= (ds
->linesize
* (dst_y
+ y
) + vs
->depth
* dst_x
);
346 src_row
= ds
->data
+ src
;
347 dst_row
= ds
->data
+ dst
;
348 old_row
= vs
->old_data
+ dst
;
350 for (y
= 0; y
< h
; y
++) {
351 memmove(old_row
, src_row
, w
* vs
->depth
);
352 memmove(dst_row
, src_row
, w
* vs
->depth
);
358 vnc_write_u8(vs
, 0); /* msg id */
360 vnc_write_u16(vs
, 1); /* number of rects */
361 vnc_framebuffer_update(vs
, dst_x
, dst_y
, w
, h
, 1);
362 vnc_write_u16(vs
, src_x
);
363 vnc_write_u16(vs
, src_y
);
367 static int find_dirty_height(VncState
*vs
, int y
, int last_x
, int x
)
371 for (h
= 1; h
< (vs
->height
- y
); h
++) {
373 if (!vnc_get_bit(vs
->dirty_row
[y
+ h
], last_x
))
375 for (tmp_x
= last_x
; tmp_x
< x
; tmp_x
++)
376 vnc_clear_bit(vs
->dirty_row
[y
+ h
], tmp_x
);
382 static void vnc_update_client(void *opaque
)
384 VncState
*vs
= opaque
;
386 if (vs
->need_update
&& vs
->csock
!= -1) {
390 uint32_t width_mask
[VNC_DIRTY_WORDS
];
395 vnc_set_bits(width_mask
, (vs
->width
/ 16), VNC_DIRTY_WORDS
);
397 /* Walk through the dirty map and eliminate tiles that
398 really aren't dirty */
400 old_row
= vs
->old_data
;
402 for (y
= 0; y
< vs
->height
; y
++) {
403 if (vnc_and_bits(vs
->dirty_row
[y
], width_mask
, VNC_DIRTY_WORDS
)) {
410 for (x
= 0; x
< vs
->ds
->width
; x
+= 16) {
411 if (memcmp(old_ptr
, ptr
, 16 * vs
->depth
) == 0) {
412 vnc_clear_bit(vs
->dirty_row
[y
], (x
/ 16));
415 memcpy(old_ptr
, ptr
, 16 * vs
->depth
);
418 ptr
+= 16 * vs
->depth
;
419 old_ptr
+= 16 * vs
->depth
;
423 row
+= vs
->ds
->linesize
;
424 old_row
+= vs
->ds
->linesize
;
428 qemu_mod_timer(vs
->timer
, qemu_get_clock(rt_clock
) + VNC_REFRESH_INTERVAL
);
432 /* Count rectangles */
434 vnc_write_u8(vs
, 0); /* msg id */
436 saved_offset
= vs
->output
.offset
;
437 vnc_write_u16(vs
, 0);
439 for (y
= 0; y
< vs
->height
; y
++) {
442 for (x
= 0; x
< vs
->width
/ 16; x
++) {
443 if (vnc_get_bit(vs
->dirty_row
[y
], x
)) {
447 vnc_clear_bit(vs
->dirty_row
[y
], x
);
450 int h
= find_dirty_height(vs
, y
, last_x
, x
);
451 send_framebuffer_update(vs
, last_x
* 16, y
, (x
- last_x
) * 16, h
);
458 int h
= find_dirty_height(vs
, y
, last_x
, x
);
459 send_framebuffer_update(vs
, last_x
* 16, y
, (x
- last_x
) * 16, h
);
463 vs
->output
.buffer
[saved_offset
] = (n_rectangles
>> 8) & 0xFF;
464 vs
->output
.buffer
[saved_offset
+ 1] = n_rectangles
& 0xFF;
468 qemu_mod_timer(vs
->timer
, qemu_get_clock(rt_clock
) + VNC_REFRESH_INTERVAL
);
471 static void vnc_timer_init(VncState
*vs
)
473 if (vs
->timer
== NULL
) {
474 vs
->timer
= qemu_new_timer(rt_clock
, vnc_update_client
, vs
);
475 qemu_mod_timer(vs
->timer
, qemu_get_clock(rt_clock
));
479 static void vnc_dpy_refresh(DisplayState
*ds
)
481 VncState
*vs
= ds
->opaque
;
486 static int vnc_listen_poll(void *opaque
)
488 VncState
*vs
= opaque
;
494 static void buffer_reserve(Buffer
*buffer
, size_t len
)
496 if ((buffer
->capacity
- buffer
->offset
) < len
) {
497 buffer
->capacity
+= (len
+ 1024);
498 buffer
->buffer
= realloc(buffer
->buffer
, buffer
->capacity
);
499 if (buffer
->buffer
== NULL
) {
500 fprintf(stderr
, "vnc: out of memory\n");
506 static int buffer_empty(Buffer
*buffer
)
508 return buffer
->offset
== 0;
511 static char *buffer_end(Buffer
*buffer
)
513 return buffer
->buffer
+ buffer
->offset
;
516 static void buffer_reset(Buffer
*buffer
)
521 static void buffer_append(Buffer
*buffer
, const void *data
, size_t len
)
523 memcpy(buffer
->buffer
+ buffer
->offset
, data
, len
);
524 buffer
->offset
+= len
;
527 static int vnc_client_io_error(VncState
*vs
, int ret
, int last_errno
)
529 if (ret
== 0 || ret
== -1) {
530 if (ret
== -1 && (last_errno
== EINTR
|| last_errno
== EAGAIN
))
533 qemu_set_fd_handler2(vs
->csock
, NULL
, NULL
, NULL
, NULL
);
534 closesocket(vs
->csock
);
536 buffer_reset(&vs
->input
);
537 buffer_reset(&vs
->output
);
544 static void vnc_client_error(VncState
*vs
)
546 vnc_client_io_error(vs
, -1, EINVAL
);
549 static void vnc_client_write(void *opaque
)
552 VncState
*vs
= opaque
;
554 ret
= send(vs
->csock
, vs
->output
.buffer
, vs
->output
.offset
, 0);
555 ret
= vnc_client_io_error(vs
, ret
, socket_error());
559 memmove(vs
->output
.buffer
, vs
->output
.buffer
+ ret
, (vs
->output
.offset
- ret
));
560 vs
->output
.offset
-= ret
;
562 if (vs
->output
.offset
== 0) {
563 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, NULL
, vs
);
567 static void vnc_read_when(VncState
*vs
, VncReadEvent
*func
, size_t expecting
)
569 vs
->read_handler
= func
;
570 vs
->read_handler_expect
= expecting
;
573 static void vnc_client_read(void *opaque
)
575 VncState
*vs
= opaque
;
578 buffer_reserve(&vs
->input
, 4096);
580 ret
= recv(vs
->csock
, buffer_end(&vs
->input
), 4096, 0);
581 ret
= vnc_client_io_error(vs
, ret
, socket_error());
585 vs
->input
.offset
+= ret
;
587 while (vs
->read_handler
&& vs
->input
.offset
>= vs
->read_handler_expect
) {
588 size_t len
= vs
->read_handler_expect
;
591 ret
= vs
->read_handler(vs
, vs
->input
.buffer
, len
);
596 memmove(vs
->input
.buffer
, vs
->input
.buffer
+ len
, (vs
->input
.offset
- len
));
597 vs
->input
.offset
-= len
;
599 vs
->read_handler_expect
= ret
;
604 static void vnc_write(VncState
*vs
, const void *data
, size_t len
)
606 buffer_reserve(&vs
->output
, len
);
608 if (buffer_empty(&vs
->output
)) {
609 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, vnc_client_write
, vs
);
612 buffer_append(&vs
->output
, data
, len
);
615 static void vnc_write_s32(VncState
*vs
, int32_t value
)
617 vnc_write_u32(vs
, *(uint32_t *)&value
);
620 static void vnc_write_u32(VncState
*vs
, uint32_t value
)
624 buf
[0] = (value
>> 24) & 0xFF;
625 buf
[1] = (value
>> 16) & 0xFF;
626 buf
[2] = (value
>> 8) & 0xFF;
627 buf
[3] = value
& 0xFF;
629 vnc_write(vs
, buf
, 4);
632 static void vnc_write_u16(VncState
*vs
, uint16_t value
)
636 buf
[0] = (value
>> 8) & 0xFF;
637 buf
[1] = value
& 0xFF;
639 vnc_write(vs
, buf
, 2);
642 static void vnc_write_u8(VncState
*vs
, uint8_t value
)
644 vnc_write(vs
, (char *)&value
, 1);
647 static void vnc_flush(VncState
*vs
)
649 if (vs
->output
.offset
)
650 vnc_client_write(vs
);
653 static uint8_t read_u8(uint8_t *data
, size_t offset
)
658 static uint16_t read_u16(uint8_t *data
, size_t offset
)
660 return ((data
[offset
] & 0xFF) << 8) | (data
[offset
+ 1] & 0xFF);
663 static int32_t read_s32(uint8_t *data
, size_t offset
)
665 return (int32_t)((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
666 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
669 static uint32_t read_u32(uint8_t *data
, size_t offset
)
671 return ((data
[offset
] << 24) | (data
[offset
+ 1] << 16) |
672 (data
[offset
+ 2] << 8) | data
[offset
+ 3]);
675 static void client_cut_text(VncState
*vs
, size_t len
, char *text
)
679 static void check_pointer_type_change(VncState
*vs
, int absolute
)
681 if (vs
->has_pointer_type_change
&& vs
->absolute
!= absolute
) {
684 vnc_write_u16(vs
, 1);
685 vnc_framebuffer_update(vs
, absolute
, 0,
686 vs
->ds
->width
, vs
->ds
->height
, -257);
689 vs
->absolute
= absolute
;
692 static void pointer_event(VncState
*vs
, int button_mask
, int x
, int y
)
697 if (button_mask
& 0x01)
698 buttons
|= MOUSE_EVENT_LBUTTON
;
699 if (button_mask
& 0x02)
700 buttons
|= MOUSE_EVENT_MBUTTON
;
701 if (button_mask
& 0x04)
702 buttons
|= MOUSE_EVENT_RBUTTON
;
703 if (button_mask
& 0x08)
705 if (button_mask
& 0x10)
709 kbd_mouse_event(x
* 0x7FFF / vs
->ds
->width
,
710 y
* 0x7FFF / vs
->ds
->height
,
712 } else if (vs
->has_pointer_type_change
) {
716 kbd_mouse_event(x
, y
, dz
, buttons
);
718 if (vs
->last_x
!= -1)
719 kbd_mouse_event(x
- vs
->last_x
,
726 check_pointer_type_change(vs
, kbd_mouse_is_absolute());
729 static void reset_keys(VncState
*vs
)
732 for(i
= 0; i
< 256; i
++) {
733 if (vs
->modifiers_state
[i
]) {
735 kbd_put_keycode(0xe0);
736 kbd_put_keycode(i
| 0x80);
737 vs
->modifiers_state
[i
] = 0;
742 static void do_key_event(VncState
*vs
, int down
, uint32_t sym
)
746 keycode
= keysym2scancode(vs
->kbd_layout
, sym
& 0xFFFF);
748 /* QEMU console switch */
750 case 0x2a: /* Left Shift */
751 case 0x36: /* Right Shift */
752 case 0x1d: /* Left CTRL */
753 case 0x9d: /* Right CTRL */
754 case 0x38: /* Left ALT */
755 case 0xb8: /* Right ALT */
757 vs
->modifiers_state
[keycode
] = 1;
759 vs
->modifiers_state
[keycode
] = 0;
761 case 0x02 ... 0x0a: /* '1' to '9' keys */
762 if (down
&& vs
->modifiers_state
[0x1d] && vs
->modifiers_state
[0x38]) {
763 /* Reset the modifiers sent to the current console */
765 console_select(keycode
- 0x02);
771 if (is_graphic_console()) {
773 kbd_put_keycode(0xe0);
775 kbd_put_keycode(keycode
& 0x7f);
777 kbd_put_keycode(keycode
| 0x80);
779 /* QEMU console emulation */
782 case 0x2a: /* Left Shift */
783 case 0x36: /* Right Shift */
784 case 0x1d: /* Left CTRL */
785 case 0x9d: /* Right CTRL */
786 case 0x38: /* Left ALT */
787 case 0xb8: /* Right ALT */
790 kbd_put_keysym(QEMU_KEY_UP
);
793 kbd_put_keysym(QEMU_KEY_DOWN
);
796 kbd_put_keysym(QEMU_KEY_LEFT
);
799 kbd_put_keysym(QEMU_KEY_RIGHT
);
802 kbd_put_keysym(QEMU_KEY_DELETE
);
805 kbd_put_keysym(QEMU_KEY_HOME
);
808 kbd_put_keysym(QEMU_KEY_END
);
811 kbd_put_keysym(QEMU_KEY_PAGEUP
);
814 kbd_put_keysym(QEMU_KEY_PAGEDOWN
);
824 static void key_event(VncState
*vs
, int down
, uint32_t sym
)
826 if (sym
>= 'A' && sym
<= 'Z')
827 sym
= sym
- 'A' + 'a';
828 do_key_event(vs
, down
, sym
);
831 static void framebuffer_update_request(VncState
*vs
, int incremental
,
832 int x_position
, int y_position
,
838 char *old_row
= vs
->old_data
+ y_position
* vs
->ds
->linesize
;
840 for (i
= 0; i
< h
; i
++) {
841 vnc_set_bits(vs
->dirty_row
[y_position
+ i
],
842 (vs
->ds
->width
/ 16), VNC_DIRTY_WORDS
);
843 memset(old_row
, 42, vs
->ds
->width
* vs
->depth
);
844 old_row
+= vs
->ds
->linesize
;
849 static void set_encodings(VncState
*vs
, int32_t *encodings
, size_t n_encodings
)
855 vs
->has_pointer_type_change
= 0;
857 vs
->ds
->dpy_copy
= NULL
;
859 for (i
= n_encodings
- 1; i
>= 0; i
--) {
860 switch (encodings
[i
]) {
864 case 1: /* CopyRect */
865 vs
->ds
->dpy_copy
= vnc_copy
;
867 case 5: /* Hextile */
870 case -223: /* DesktopResize */
874 vs
->has_pointer_type_change
= 1;
881 check_pointer_type_change(vs
, kbd_mouse_is_absolute());
884 static int compute_nbits(unsigned int val
)
895 static void set_pixel_format(VncState
*vs
,
896 int bits_per_pixel
, int depth
,
897 int big_endian_flag
, int true_color_flag
,
898 int red_max
, int green_max
, int blue_max
,
899 int red_shift
, int green_shift
, int blue_shift
)
901 int host_big_endian_flag
;
903 #ifdef WORDS_BIGENDIAN
904 host_big_endian_flag
= 1;
906 host_big_endian_flag
= 0;
908 if (!true_color_flag
) {
910 vnc_client_error(vs
);
913 if (bits_per_pixel
== 32 &&
914 host_big_endian_flag
== big_endian_flag
&&
915 red_max
== 0xff && green_max
== 0xff && blue_max
== 0xff &&
916 red_shift
== 16 && green_shift
== 8 && blue_shift
== 0) {
918 vs
->write_pixels
= vnc_write_pixels_copy
;
919 vs
->send_hextile_tile
= send_hextile_tile_32
;
921 if (bits_per_pixel
== 16 &&
922 host_big_endian_flag
== big_endian_flag
&&
923 red_max
== 31 && green_max
== 63 && blue_max
== 31 &&
924 red_shift
== 11 && green_shift
== 5 && blue_shift
== 0) {
926 vs
->write_pixels
= vnc_write_pixels_copy
;
927 vs
->send_hextile_tile
= send_hextile_tile_16
;
929 if (bits_per_pixel
== 8 &&
930 red_max
== 7 && green_max
== 7 && blue_max
== 3 &&
931 red_shift
== 5 && green_shift
== 2 && blue_shift
== 0) {
933 vs
->write_pixels
= vnc_write_pixels_copy
;
934 vs
->send_hextile_tile
= send_hextile_tile_8
;
937 /* generic and slower case */
938 if (bits_per_pixel
!= 8 &&
939 bits_per_pixel
!= 16 &&
940 bits_per_pixel
!= 32)
943 vs
->red_shift
= red_shift
;
944 vs
->red_max
= red_max
;
945 vs
->red_shift1
= 24 - compute_nbits(red_max
);
946 vs
->green_shift
= green_shift
;
947 vs
->green_max
= green_max
;
948 vs
->green_shift1
= 16 - compute_nbits(green_max
);
949 vs
->blue_shift
= blue_shift
;
950 vs
->blue_max
= blue_max
;
951 vs
->blue_shift1
= 8 - compute_nbits(blue_max
);
952 vs
->pix_bpp
= bits_per_pixel
/ 8;
953 vs
->pix_big_endian
= big_endian_flag
;
954 vs
->write_pixels
= vnc_write_pixels_generic
;
955 vs
->send_hextile_tile
= send_hextile_tile_generic
;
958 vnc_dpy_resize(vs
->ds
, vs
->ds
->width
, vs
->ds
->height
);
959 memset(vs
->dirty_row
, 0xFF, sizeof(vs
->dirty_row
));
960 memset(vs
->old_data
, 42, vs
->ds
->linesize
* vs
->ds
->height
);
966 static int protocol_client_msg(VncState
*vs
, char *data
, size_t len
)
976 set_pixel_format(vs
, read_u8(data
, 4), read_u8(data
, 5),
977 read_u8(data
, 6), read_u8(data
, 7),
978 read_u16(data
, 8), read_u16(data
, 10),
979 read_u16(data
, 12), read_u8(data
, 14),
980 read_u8(data
, 15), read_u8(data
, 16));
987 return 4 + (read_u16(data
, 2) * 4);
989 limit
= read_u16(data
, 2);
990 for (i
= 0; i
< limit
; i
++) {
991 int32_t val
= read_s32(data
, 4 + (i
* 4));
992 memcpy(data
+ 4 + (i
* 4), &val
, sizeof(val
));
995 set_encodings(vs
, (int32_t *)(data
+ 4), limit
);
1001 framebuffer_update_request(vs
,
1002 read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4),
1003 read_u16(data
, 6), read_u16(data
, 8));
1009 key_event(vs
, read_u8(data
, 1), read_u32(data
, 4));
1015 pointer_event(vs
, read_u8(data
, 1), read_u16(data
, 2), read_u16(data
, 4));
1022 return 8 + read_u32(data
, 4);
1024 client_cut_text(vs
, read_u32(data
, 4), data
+ 8);
1027 printf("Msg: %d\n", data
[0]);
1028 vnc_client_error(vs
);
1032 vnc_read_when(vs
, protocol_client_msg
, 1);
1036 static int protocol_client_init(VncState
*vs
, char *data
, size_t len
)
1038 char pad
[3] = { 0, 0, 0 };
1040 vs
->width
= vs
->ds
->width
;
1041 vs
->height
= vs
->ds
->height
;
1042 vnc_write_u16(vs
, vs
->ds
->width
);
1043 vnc_write_u16(vs
, vs
->ds
->height
);
1045 vnc_write_u8(vs
, vs
->depth
* 8); /* bits-per-pixel */
1046 vnc_write_u8(vs
, vs
->depth
* 8); /* depth */
1047 #ifdef WORDS_BIGENDIAN
1048 vnc_write_u8(vs
, 1); /* big-endian-flag */
1050 vnc_write_u8(vs
, 0); /* big-endian-flag */
1052 vnc_write_u8(vs
, 1); /* true-color-flag */
1053 if (vs
->depth
== 4) {
1054 vnc_write_u16(vs
, 0xFF); /* red-max */
1055 vnc_write_u16(vs
, 0xFF); /* green-max */
1056 vnc_write_u16(vs
, 0xFF); /* blue-max */
1057 vnc_write_u8(vs
, 16); /* red-shift */
1058 vnc_write_u8(vs
, 8); /* green-shift */
1059 vnc_write_u8(vs
, 0); /* blue-shift */
1060 vs
->send_hextile_tile
= send_hextile_tile_32
;
1061 } else if (vs
->depth
== 2) {
1062 vnc_write_u16(vs
, 31); /* red-max */
1063 vnc_write_u16(vs
, 63); /* green-max */
1064 vnc_write_u16(vs
, 31); /* blue-max */
1065 vnc_write_u8(vs
, 11); /* red-shift */
1066 vnc_write_u8(vs
, 5); /* green-shift */
1067 vnc_write_u8(vs
, 0); /* blue-shift */
1068 vs
->send_hextile_tile
= send_hextile_tile_16
;
1069 } else if (vs
->depth
== 1) {
1070 /* XXX: change QEMU pixel 8 bit pixel format to match the VNC one ? */
1071 vnc_write_u16(vs
, 7); /* red-max */
1072 vnc_write_u16(vs
, 7); /* green-max */
1073 vnc_write_u16(vs
, 3); /* blue-max */
1074 vnc_write_u8(vs
, 5); /* red-shift */
1075 vnc_write_u8(vs
, 2); /* green-shift */
1076 vnc_write_u8(vs
, 0); /* blue-shift */
1077 vs
->send_hextile_tile
= send_hextile_tile_8
;
1079 vs
->write_pixels
= vnc_write_pixels_copy
;
1081 vnc_write(vs
, pad
, 3); /* padding */
1083 vnc_write_u32(vs
, 4);
1084 vnc_write(vs
, "QEMU", 4);
1087 vnc_read_when(vs
, protocol_client_msg
, 1);
1092 static int protocol_version(VncState
*vs
, char *version
, size_t len
)
1097 memcpy(local
, version
, 12);
1100 if (sscanf(local
, "RFB %03d.%03d\n", &maj
, &min
) != 2) {
1101 vnc_client_error(vs
);
1105 vnc_write_u32(vs
, 1); /* None */
1108 vnc_read_when(vs
, protocol_client_init
, 1);
1113 static void vnc_listen_read(void *opaque
)
1115 VncState
*vs
= opaque
;
1116 struct sockaddr_in addr
;
1117 socklen_t addrlen
= sizeof(addr
);
1119 vs
->csock
= accept(vs
->lsock
, (struct sockaddr
*)&addr
, &addrlen
);
1120 if (vs
->csock
!= -1) {
1121 socket_set_nonblock(vs
->csock
);
1122 qemu_set_fd_handler2(vs
->csock
, NULL
, vnc_client_read
, NULL
, opaque
);
1123 vnc_write(vs
, "RFB 003.003\n", 12);
1125 vnc_read_when(vs
, protocol_version
, 12);
1126 memset(vs
->old_data
, 0, vs
->ds
->linesize
* vs
->ds
->height
);
1127 memset(vs
->dirty_row
, 0xFF, sizeof(vs
->dirty_row
));
1129 vs
->has_hextile
= 0;
1130 vs
->ds
->dpy_copy
= NULL
;
1134 extern int parse_host_port(struct sockaddr_in
*saddr
, const char *str
);
1136 void vnc_display_init(DisplayState
*ds
, const char *arg
)
1138 struct sockaddr
*addr
;
1139 struct sockaddr_in iaddr
;
1141 struct sockaddr_un uaddr
;
1143 int reuse_addr
, ret
;
1148 vs
= qemu_mallocz(sizeof(VncState
));
1162 if (!keyboard_layout
)
1163 keyboard_layout
= "en-us";
1165 vs
->kbd_layout
= init_keyboard_layout(keyboard_layout
);
1166 if (!vs
->kbd_layout
)
1169 vs
->ds
->data
= NULL
;
1170 vs
->ds
->dpy_update
= vnc_dpy_update
;
1171 vs
->ds
->dpy_resize
= vnc_dpy_resize
;
1172 vs
->ds
->dpy_refresh
= vnc_dpy_refresh
;
1174 memset(vs
->dirty_row
, 0xFF, sizeof(vs
->dirty_row
));
1176 vnc_dpy_resize(vs
->ds
, 640, 400);
1179 if (strstart(arg
, "unix:", &p
)) {
1180 addr
= (struct sockaddr
*)&uaddr
;
1181 addrlen
= sizeof(uaddr
);
1183 vs
->lsock
= socket(PF_UNIX
, SOCK_STREAM
, 0);
1184 if (vs
->lsock
== -1) {
1185 fprintf(stderr
, "Could not create socket\n");
1189 uaddr
.sun_family
= AF_UNIX
;
1190 memset(uaddr
.sun_path
, 0, 108);
1191 snprintf(uaddr
.sun_path
, 108, "%s", p
);
1193 unlink(uaddr
.sun_path
);
1197 addr
= (struct sockaddr
*)&iaddr
;
1198 addrlen
= sizeof(iaddr
);
1200 vs
->lsock
= socket(PF_INET
, SOCK_STREAM
, 0);
1201 if (vs
->lsock
== -1) {
1202 fprintf(stderr
, "Could not create socket\n");
1206 if (parse_host_port(&iaddr
, arg
) < 0) {
1207 fprintf(stderr
, "Could not parse VNC address\n");
1211 iaddr
.sin_port
= htons(ntohs(iaddr
.sin_port
) + 5900);
1214 ret
= setsockopt(vs
->lsock
, SOL_SOCKET
, SO_REUSEADDR
,
1215 (const char *)&reuse_addr
, sizeof(reuse_addr
));
1217 fprintf(stderr
, "setsockopt() failed\n");
1222 if (bind(vs
->lsock
, addr
, addrlen
) == -1) {
1223 fprintf(stderr
, "bind() failed\n");
1227 if (listen(vs
->lsock
, 1) == -1) {
1228 fprintf(stderr
, "listen() failed\n");
1232 ret
= qemu_set_fd_handler2(vs
->lsock
, vnc_listen_poll
, vnc_listen_read
, NULL
, vs
);