RPJosh
/
neatvnc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Re-format using clang-format

tight-png
Andri Yngvason 2019-10-20 22:13:51 +00:00
parent 13c52175d2
commit 80b1f3cb4c
20 changed files with 428 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
examples/draw.c
View File

@ -28,19 +28,19 @@ struct draw {
struct nvnc_fb* fb;
};
void on_pointer_event(struct nvnc_client *client, uint16_t x, uint16_t y,
void on_pointer_event(struct nvnc_client* client, uint16_t x, uint16_t y,
enum nvnc_button_mask buttons)
{
if (!(buttons & NVNC_BUTTON_LEFT))
return;
struct nvnc *server = nvnc_get_server(client);
struct nvnc* server = nvnc_get_server(client);
assert(server);
struct draw *draw = nvnc_get_userdata(server);
struct draw* draw = nvnc_get_userdata(server);
assert(draw);
uint32_t *image = nvnc_fb_get_addr(draw->fb);
uint32_t* image = nvnc_fb_get_addr(draw->fb);
int width = nvnc_fb_get_width(draw->fb);
int height = nvnc_fb_get_height(draw->fb);
@ -53,7 +53,7 @@ void on_pointer_event(struct nvnc_client *client, uint16_t x, uint16_t y,
pixman_region_fini(&region);
}
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
struct draw draw;
@ -66,7 +66,7 @@ int main(int argc, char *argv[])
memset(addr, 0xff, width * height * 4);
struct nvnc *server = nvnc_open("127.0.0.1", 5900);
struct nvnc* server = nvnc_open("127.0.0.1", 5900);
nvnc_set_dimensions(server, width, height, format);
nvnc_set_name(server, "Draw");

8
examples/png-server.c
View File

@ -21,11 +21,11 @@
#include <assert.h>
#include <pixman.h>
struct nvnc_fb* read_png_file(const char *filename);
struct nvnc_fb* read_png_file(const char* filename);
int main(int argc, char *argv[])
int main(int argc, char* argv[])
{
const char *file = argv[1];
const char* file = argv[1];
if (!file) {
printf("Missing argument\n");
@ -38,7 +38,7 @@ int main(int argc, char *argv[])
return 1;
}
struct nvnc *server = nvnc_open("127.0.0.1", 5900);
struct nvnc* server = nvnc_open("127.0.0.1", 5900);
int width = nvnc_fb_get_width(fb);
int height = nvnc_fb_get_height(fb);

3
include/fb.h
View File

@ -5,11 +5,10 @@
struct nvnc_fb {
int ref;
void *addr;
void* addr;
size_t size;
uint16_t width;
uint16_t height;
uint32_t fourcc_format;
uint64_t fourcc_modifier;
};

1
include/likely.h
View File

@ -18,4 +18,3 @@
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

39
include/neatvnc.h
View File

@ -32,33 +32,34 @@ enum nvnc_button_mask {
NVNC_SCROLL_DOWN = 1 << 4,
};
typedef void (*nvnc_key_fn)(struct nvnc_client*, uint32_t keysym, bool is_pressed);
typedef void (*nvnc_key_fn)(struct nvnc_client*, uint32_t keysym,
bool is_pressed);
typedef void (*nvnc_pointer_fn)(struct nvnc_client*, uint16_t x, uint16_t y,
enum nvnc_button_mask);
typedef void (*nvnc_fb_req_fn)(struct nvnc_client*, bool is_incremental,
uint16_t x, uint16_t y,
uint16_t width, uint16_t height);
uint16_t x, uint16_t y, uint16_t width,
uint16_t height);
typedef void (*nvnc_client_fn)(struct nvnc_client*);
typedef void (*nvnc_damage_fn)(struct pixman_region16 *damage, void *userdata);
typedef void (*nvnc_damage_fn)(struct pixman_region16* damage, void* userdata);
struct nvnc *nvnc_open(const char *addr, uint16_t port);
void nvnc_close(struct nvnc *self);
struct nvnc* nvnc_open(const char* addr, uint16_t port);
void nvnc_close(struct nvnc* self);
void nvnc_set_userdata(void *self, void* userdata);
void* nvnc_get_userdata(const void *self);
void nvnc_set_userdata(void* self, void* userdata);
void* nvnc_get_userdata(const void* self);
struct nvnc *nvnc_get_server(const struct nvnc_client *client);
struct nvnc* nvnc_get_server(const struct nvnc_client* client);
void nvnc_set_dimensions(struct nvnc *self, uint16_t width, uint16_t height,
void nvnc_set_dimensions(struct nvnc* self, uint16_t width, uint16_t height,
uint32_t fourcc_format);
void nvnc_set_name(struct nvnc *self, const char *name);
void nvnc_set_name(struct nvnc* self, const char* name);
void nvnc_set_key_fn(struct nvnc *self, nvnc_key_fn);
void nvnc_set_pointer_fn(struct nvnc *self, nvnc_pointer_fn);
void nvnc_set_fb_req_fn(struct nvnc *self, nvnc_fb_req_fn);
void nvnc_set_new_client_fn(struct nvnc *self, nvnc_client_fn);
void nvnc_set_client_cleanup_fn(struct nvnc_client *self, nvnc_client_fn fn);
void nvnc_set_key_fn(struct nvnc* self, nvnc_key_fn);
void nvnc_set_pointer_fn(struct nvnc* self, nvnc_pointer_fn);
void nvnc_set_fb_req_fn(struct nvnc* self, nvnc_fb_req_fn);
void nvnc_set_new_client_fn(struct nvnc* self, nvnc_client_fn);
void nvnc_set_client_cleanup_fn(struct nvnc_client* self, nvnc_client_fn fn);
struct nvnc_fb* nvnc_fb_new(uint16_t width, uint16_t height,
uint32_t fourcc_format);
@ -75,7 +76,7 @@ uint32_t nvnc_fb_get_fourcc_format(const struct nvnc_fb* fb);
* Feed a new frame to the server. The damaged region is sent to clients
* immediately.
*/
int nvnc_feed_frame(struct nvnc *self, struct nvnc_fb* fb,
int nvnc_feed_frame(struct nvnc* self, struct nvnc_fb* fb,
const struct pixman_region16* damage);
/*
@ -84,6 +85,6 @@ int nvnc_feed_frame(struct nvnc *self, struct nvnc_fb* fb,
*
* This is a utility function that may be used to reduce network traffic.
*/
int nvnc_check_damage(const struct nvnc_fb *fb0, const struct nvnc_fb *fb1,
int nvnc_check_damage(const struct nvnc_fb* fb0, const struct nvnc_fb* fb1,
int x_hint, int y_hint, int width_hint, int height_hint,
nvnc_damage_fn on_check_done, void *userdata);
nvnc_damage_fn on_check_done, void* userdata);

4
include/pixels.h
View File

@ -18,8 +18,8 @@
#include <stdint.h>
void pixel32_to_cpixel(uint8_t *restrict dst,
void pixel32_to_cpixel(uint8_t* restrict dst,
const struct rfb_pixel_format* dst_fmt,
const uint32_t *restrict src,
const uint32_t* restrict src,
const struct rfb_pixel_format* src_fmt,
size_t bytes_per_cpixel, size_t len);

9
include/raw-encoding.h
View File

@ -5,8 +5,7 @@ struct rfb_pixel_format;
struct pixman_region16;
struct vec;
int raw_encode_frame(struct vec *dst,
const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *src,
const struct rfb_pixel_format *src_fmt,
struct pixman_region16 *region);
int raw_encode_frame(struct vec* dst, const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* src,
const struct rfb_pixel_format* src_fmt,
struct pixman_region16* region);

4
include/type-macros.h
View File

@ -20,6 +20,6 @@
#define container_of(ptr, type, member) \
({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) ); \
const typeof(((type*)0)->member)* __mptr = (ptr); \
(type*)((char*)__mptr - offsetof(type, member)); \
})

4
include/util.h
View File

@ -27,7 +27,7 @@ struct vnc_write_request {
uv_buf_t buffer;
};
int vnc__write(uv_stream_t *stream, const void *payload, size_t size,
int vnc__write(uv_stream_t* stream, const void* payload, size_t size,
uv_write_cb on_done);
int rfb_pixfmt_from_fourcc(struct rfb_pixel_format *dst, uint32_t src);
int rfb_pixfmt_from_fourcc(struct rfb_pixel_format* dst, uint32_t src);

4
include/vec.h
View File

@ -59,12 +59,12 @@ static inline void vec_fast_append_32(struct vec* vec, uint32_t value)
#define vec_for(elem, vec) \
for (elem = (vec)->data; \
((ptrdiff_t)elem - (ptrdiff_t)(vec)->data) < (ptrdiff_t)(vec)->len; \
((ptrdiff_t)elem - (ptrdiff_t)(vec)->data) < (ptrdiff_t)(vec)->len;\
++elem)
#define vec_for_tail(elem, vec) \
for (elem = (vec)->data, ++elem; \
((ptrdiff_t)elem - (ptrdiff_t)(vec)->data) < (ptrdiff_t)(vec)->len; \
((ptrdiff_t)elem - (ptrdiff_t)(vec)->data) < (ptrdiff_t)(vec)->len;\
++elem)
#define vec_for_ptr(elem, vec) \

11
include/zrle.h
View File

@ -26,9 +26,8 @@ struct rfb_pixel_format;
struct pixman_region16;
struct vec;
int zrle_encode_frame(z_stream *zs,
struct vec *dst,
const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *src,
const struct rfb_pixel_format *src_fmt,
struct pixman_region16 *region);
int zrle_encode_frame(z_stream* zs, struct vec* dst,
const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* src,
const struct rfb_pixel_format* src_fmt,
struct pixman_region16* region);

58
src/damage.c
View File

@ -16,23 +16,22 @@
struct damage_check {
uv_work_t work;
const struct nvnc_fb *fb0;
const struct nvnc_fb *fb1;
const struct nvnc_fb* fb0;
const struct nvnc_fb* fb1;
int x_hint;
int y_hint;
int width_hint;
int height_hint;
nvnc_damage_fn on_done;
struct pixman_region16 damage;
void *userdata;
void* userdata;
};
static bool fbs_are_compatible(const struct nvnc_fb *fb0,
const struct nvnc_fb *fb1)
static bool fbs_are_compatible(const struct nvnc_fb* fb0,
const struct nvnc_fb* fb1)
{
return fb0->fourcc_format == fb1->fourcc_format
&& fb0->width == fb1->width
&& fb0->height == fb1->height;
return fb0->fourcc_format == fb1->fourcc_format &&
fb0->width == fb1->width && fb0->height == fb1->height;
}
static inline bool are_tiles_equal(const uint32_t* a, const uint32_t* b,
@ -46,12 +45,12 @@ static inline bool are_tiles_equal(const uint32_t* a, const uint32_t* b,
}
#define TILE_SIDE_LENGTH 32
int check_damage_linear(struct pixman_region16 *damage,
const struct nvnc_fb *fb0, const struct nvnc_fb *fb1,
int check_damage_linear(struct pixman_region16* damage,
const struct nvnc_fb* fb0, const struct nvnc_fb* fb1,
int x_hint, int y_hint, int width_hint, int height_hint)
{
uint32_t *b0 = fb0->addr;
uint32_t *b1 = fb1->addr;
uint32_t* b0 = fb0->addr;
uint32_t* b1 = fb1->addr;
int width = fb0->width;
int height = fb0->height;
@ -62,8 +61,7 @@ int check_damage_linear(struct pixman_region16 *damage,
int x_start = ALIGN_DOWN(x_hint, TILE_SIDE_LENGTH);
int y_start = ALIGN_DOWN(y_hint, TILE_SIDE_LENGTH);
for (int y = y_start; y < y_start + height_hint;
y += TILE_SIDE_LENGTH) {
for (int y = y_start; y < y_start + height_hint; y += TILE_SIDE_LENGTH) {
int tile_height = MIN(TILE_SIDE_LENGTH, height - y);
for (int x = x_start; x < x_start + width_hint;
@ -72,8 +70,8 @@ int check_damage_linear(struct pixman_region16 *damage,
int offset = x + y * width;
if (are_tiles_equal(b0 + offset, b1 + offset,
width, tile_width, tile_height))
if (are_tiles_equal(b0 + offset, b1 + offset, width,
tile_width, tile_height))
continue;
pixman_region_union_rect(damage, damage, x, y,
@ -85,20 +83,20 @@ int check_damage_linear(struct pixman_region16 *damage,
}
#undef TILE_SIDE_LENGTH
void do_damage_check_linear(uv_work_t *work)
void do_damage_check_linear(uv_work_t* work)
{
struct damage_check *check = (void*)work;
struct damage_check* check = (void*)work;
check_damage_linear(&check->damage, check->fb0, check->fb1,
check->x_hint, check->y_hint,
check->width_hint, check->height_hint);
check->x_hint, check->y_hint, check->width_hint,
check->height_hint);
}
void on_damage_check_done_linear(uv_work_t *work, int status)
void on_damage_check_done_linear(uv_work_t* work, int status)
{
(void)status;
struct damage_check *check = (void*)work;
struct damage_check* check = (void*)work;
check->on_done(&check->damage, check->userdata);
@ -106,14 +104,12 @@ void on_damage_check_done_linear(uv_work_t *work, int status)
free(check);
}
int check_damage_linear_threaded(const struct nvnc_fb *fb0,
const struct nvnc_fb *fb1,
int x_hint, int y_hint,
int width_hint, int height_hint,
nvnc_damage_fn on_check_done,
void *userdata)
int check_damage_linear_threaded(const struct nvnc_fb* fb0,
const struct nvnc_fb* fb1, int x_hint,
int y_hint, int width_hint, int height_hint,
nvnc_damage_fn on_check_done, void* userdata)
{
struct damage_check *work = calloc(1, sizeof(*work));
struct damage_check* work = calloc(1, sizeof(*work));
if (!work)
return -1;
@ -138,9 +134,9 @@ int check_damage_linear_threaded(const struct nvnc_fb *fb0,
}
EXPORT
int nvnc_check_damage(const struct nvnc_fb *fb0, const struct nvnc_fb *fb1,
int nvnc_check_damage(const struct nvnc_fb* fb0, const struct nvnc_fb* fb1,
int x_hint, int y_hint, int width_hint, int height_hint,
nvnc_damage_fn on_check_done, void *userdata)
nvnc_damage_fn on_check_done, void* userdata)
{
if (!fbs_are_compatible(fb0, fb1))
return -1;

6
src/pixels.c
View File

@ -20,9 +20,9 @@
#define POPCOUNT(x) __builtin_popcount(x)
void pixel32_to_cpixel(uint8_t *restrict dst,
void pixel32_to_cpixel(uint8_t* restrict dst,
const struct rfb_pixel_format* dst_fmt,
const uint32_t *restrict src,
const uint32_t* restrict src,
const struct rfb_pixel_format* src_fmt,
size_t bytes_per_cpixel, size_t len)
{
@ -65,7 +65,7 @@ void pixel32_to_cpixel(uint8_t *restrict dst,
uint32_t r, g, b; \
r = ((px >> src_red_shift) & src_red_max) << dst_red_bits \
>> src_red_bits << dst_red_shift; \
g = ((px >> src_green_shift) & src_green_max) << dst_green_bits \
g = ((px >> src_green_shift) & src_green_max) << dst_green_bits\
>> src_green_bits << dst_green_shift; \
b = ((px >> src_blue_shift) & src_blue_max) << dst_blue_bits \
>> src_blue_bits << dst_blue_shift; \

33
src/pngfb.c
View File

@ -13,21 +13,26 @@
#include <assert.h>
#include <libdrm/drm_fourcc.h>
struct nvnc_fb* read_png_file(const char *filename) {
struct nvnc_fb* read_png_file(const char* filename)
{
int width, height;
png_byte color_type;
png_byte bit_depth;
png_bytep *row_pointers = NULL;
png_bytep* row_pointers = NULL;
FILE *fp = fopen(filename, "rb");
FILE* fp = fopen(filename, "rb");
png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if(!png) abort();
png_structp png =
png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png)
abort();
png_infop info = png_create_info_struct(png);
if(!info) abort();
if (!info)
abort();
if(setjmp(png_jmpbuf(png))) abort();
if (setjmp(png_jmpbuf(png)))
abort();
png_init_io(png, fp);
@ -41,26 +46,26 @@ struct nvnc_fb* read_png_file(const char *filename) {
// Read any color_type into 8bit depth, RGBA format.
// See http://www.libpng.org/pub/png/libpng-manual.txt
if(bit_depth == 16)
if (bit_depth == 16)
png_set_strip_16(png);
if(color_type == PNG_COLOR_TYPE_PALETTE)
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png);
// PNG_COLOR_TYPE_GRAY_ALPHA is always 8 or 16bit depth.
if(color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
png_set_expand_gray_1_2_4_to_8(png);
if(png_get_valid(png, info, PNG_INFO_tRNS))
if (png_get_valid(png, info, PNG_INFO_tRNS))
png_set_tRNS_to_alpha(png);
// These color_type don't have an alpha channel then fill it with 0xff.
if(color_type == PNG_COLOR_TYPE_RGB ||
if (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_PALETTE)
png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
if(color_type == PNG_COLOR_TYPE_GRAY ||
if (color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
@ -71,7 +76,7 @@ struct nvnc_fb* read_png_file(const char *filename) {
struct nvnc_fb* fb = nvnc_fb_new(width, height, DRM_FORMAT_ABGR8888);
assert(fb);
uint8_t *addr = nvnc_fb_get_addr(fb);
uint8_t* addr = nvnc_fb_get_addr(fb);
row_pointers = malloc(sizeof(png_bytep) * height);
assert(row_pointers);

19
src/raw-encoding.c
View File

@ -6,10 +6,10 @@
#include <pixman.h>
int raw_encode_box(struct vec *dst, const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *fb,
const struct rfb_pixel_format *src_fmt,
int x_start, int y_start, int stride, int width, int height)
int raw_encode_box(struct vec* dst, const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* fb,
const struct rfb_pixel_format* src_fmt, int x_start,
int y_start, int stride, int width, int height)
{
int rc = -1;
@ -36,16 +36,15 @@ int raw_encode_box(struct vec *dst, const struct rfb_pixel_format *dst_fmt,
return 0;
}
int raw_encode_frame(struct vec *dst,
const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *src,
const struct rfb_pixel_format *src_fmt,
struct pixman_region16 *region)
int raw_encode_frame(struct vec* dst, const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* src,
const struct rfb_pixel_format* src_fmt,
struct pixman_region16* region)
{
int rc = -1;
int n_rects = 0;
struct pixman_box16 *box = pixman_region_rectangles(region, &n_rects);
struct pixman_box16* box = pixman_region_rectangles(region, &n_rects);
if (n_rects > UINT16_MAX) {
box = pixman_region_extents(region);
n_rects = 1;

227
src/server.c
View File

@ -66,7 +66,7 @@ struct nvnc_client {
struct nvnc_common common;
int ref;
uv_tcp_t stream_handle;
struct nvnc *server;
struct nvnc* server;
enum nvnc_client_state state;
uint32_t fourcc;
struct rfb_pixel_format pixfmt;
@ -97,7 +97,7 @@ struct nvnc {
uv_tcp_t tcp_handle;
struct nvnc_client_list clients;
struct vnc_display display;
void *userdata;
void* userdata;
nvnc_key_fn key_fn;
nvnc_pointer_fn pointer_fn;
nvnc_fb_req_fn fb_req_fn;
@ -107,14 +107,14 @@ struct nvnc {
struct fb_update_work {
uv_work_t work;
struct nvnc_client *client;
struct nvnc_client* client;
struct pixman_region16 region;
struct rfb_pixel_format server_fmt;
struct vec frame;
struct nvnc_fb *fb;
struct nvnc_fb* fb;
};
int schedule_client_update_fb(struct nvnc_client *client);
int schedule_client_update_fb(struct nvnc_client* client);
static const char* fourcc_to_string(uint32_t fourcc)
{
@ -129,8 +129,8 @@ static const char* fourcc_to_string(uint32_t fourcc)
return buffer;
}
static void allocate_read_buffer(uv_handle_t *handle, size_t suggested_size,
uv_buf_t *buf)
static void allocate_read_buffer(uv_handle_t* handle, size_t suggested_size,
uv_buf_t* buf)
{
(void)suggested_size;
@ -140,9 +140,8 @@ static void allocate_read_buffer(uv_handle_t *handle, size_t suggested_size,
static void cleanup_client(uv_handle_t* handle)
{
struct nvnc_client *client =
container_of((uv_tcp_t*)handle, struct nvnc_client,
stream_handle);
struct nvnc_client* client = container_of(
(uv_tcp_t*)handle, struct nvnc_client, stream_handle);
nvnc_client_fn fn = client->cleanup_fn;
if (fn)
@ -155,39 +154,37 @@ static void cleanup_client(uv_handle_t* handle)
free(client);
}
static inline void client_close(struct nvnc_client *client)
static inline void client_close(struct nvnc_client* client)
{
uv_close((uv_handle_t*)&client->stream_handle, cleanup_client);
}
static inline void client_unref(struct nvnc_client *client)
static inline void client_unref(struct nvnc_client* client)
{
if (--client->ref == 0)
client_close(client);
}
static inline void client_ref(struct nvnc_client *client)
static inline void client_ref(struct nvnc_client* client)
{
++client->ref;
}
static void close_after_write(uv_write_t *req, int status)
static void close_after_write(uv_write_t* req, int status)
{
struct nvnc_client* client =
container_of((uv_tcp_t*)req->handle, struct nvnc_client,
stream_handle);
struct nvnc_client* client = container_of(
(uv_tcp_t*)req->handle, struct nvnc_client, stream_handle);
client_unref(client);
}
static int handle_unsupported_version(struct nvnc_client *client)
static int handle_unsupported_version(struct nvnc_client* client)
{
char buffer[256];
client->state = VNC_CLIENT_STATE_ERROR;
struct rfb_error_reason *reason =
(struct rfb_error_reason*)(buffer + 1);
struct rfb_error_reason* reason = (struct rfb_error_reason*)(buffer + 1);
static const char reason_string[] = "Unsupported version\n";
@ -202,7 +199,7 @@ static int handle_unsupported_version(struct nvnc_client *client)
return 0;
}
static int on_version_message(struct nvnc_client *client)
static int on_version_message(struct nvnc_client* client)
{
if (client->buffer_len - client->buffer_index < 12)
return 0;
@ -214,28 +211,31 @@ static int on_version_message(struct nvnc_client *client)
if (strcmp(RFB_VERSION_MESSAGE, version_string) != 0)
return handle_unsupported_version(client);
/* clang-format off */
const static struct rfb_security_types_msg security = {
.n = 1,
.types = {
RFB_SECURITY_TYPE_NONE,
},
};
/* clang-format on */
vnc__write((uv_stream_t*)&client->stream_handle, &security, sizeof(security), NULL);
vnc__write((uv_stream_t*)&client->stream_handle, &security,
sizeof(security), NULL);
client->state = VNC_CLIENT_STATE_WAITING_FOR_SECURITY;
return 12;
}
static int handle_invalid_security_type(struct nvnc_client *client)
static int handle_invalid_security_type(struct nvnc_client* client)
{
char buffer[256];
client->state = VNC_CLIENT_STATE_ERROR;
uint8_t *result = (uint8_t*)buffer;
uint8_t* result = (uint8_t*)buffer;
struct rfb_error_reason *reason =
struct rfb_error_reason* reason =
(struct rfb_error_reason*)(buffer + sizeof(*result));
static const char reason_string[] = "Unsupported version\n";
@ -251,7 +251,7 @@ static int handle_invalid_security_type(struct nvnc_client *client)
return 0;
}
static int on_security_message(struct nvnc_client *client)
static int on_security_message(struct nvnc_client* client)
{
if (client->buffer_len - client->buffer_index < 1)
return 0;
@ -261,23 +261,25 @@ static int on_security_message(struct nvnc_client *client)
if (type != RFB_SECURITY_TYPE_NONE)
return handle_invalid_security_type(client);
enum rfb_security_handshake_result result
= htonl(RFB_SECURITY_HANDSHAKE_OK);
enum rfb_security_handshake_result result =
htonl(RFB_SECURITY_HANDSHAKE_OK);
vnc__write((uv_stream_t*)&client->stream_handle, &result, sizeof(result), NULL);
vnc__write((uv_stream_t*)&client->stream_handle, &result,
sizeof(result), NULL);
client->state = VNC_CLIENT_STATE_WAITING_FOR_INIT;
return sizeof(type);
}
static void disconnect_all_other_clients(struct nvnc_client *client)
static void disconnect_all_other_clients(struct nvnc_client* client)
{
struct nvnc_client *node;
LIST_FOREACH(node, &client->server->clients, link)
struct nvnc_client* node;
LIST_FOREACH (node, &client->server->clients, link)
if (node != client)
client_unref(client);
}
/* clang-format off */
int rfb_pixfmt_from_fourcc(struct rfb_pixel_format *dst, uint32_t src) {
switch (src & ~DRM_FORMAT_BIG_ENDIAN) {
case DRM_FORMAT_RGBA8888:
@ -396,6 +398,7 @@ static uint32_t shift_values_to_fourcc(int r, int g, int b, int bpp)
return DRM_FORMAT_INVALID;
#undef RGBEQ
}
/* clang-format on */
int get_fourcc_depth(uint32_t fourcc)
{
@ -409,14 +412,14 @@ int get_fourcc_depth(uint32_t fourcc)
}
}
uint32_t rfb_pixfmt_to_fourcc(const struct rfb_pixel_format *fmt)
uint32_t rfb_pixfmt_to_fourcc(const struct rfb_pixel_format* fmt)
{
if (!fmt->true_colour_flag)
return DRM_FORMAT_INVALID;
/* Note: The depth value given by the client is ignored */
int depth = max_values_to_depth(fmt->red_max, fmt->green_max,
fmt->blue_max);
int depth =
max_values_to_depth(fmt->red_max, fmt->green_max, fmt->blue_max);
if (depth < 0)
return DRM_FORMAT_INVALID;
@ -435,23 +438,22 @@ uint32_t rfb_pixfmt_to_fourcc(const struct rfb_pixel_format *fmt)
return fourcc;
}
static void send_server_init_message(struct nvnc_client *client)
static void send_server_init_message(struct nvnc_client* client)
{
struct nvnc *server = client->server;
struct vnc_display *display = &server->display;
struct nvnc* server = client->server;
struct vnc_display* display = &server->display;
size_t name_len = strlen(display->name);
size_t size = sizeof(struct rfb_server_init_msg) + name_len;
struct rfb_server_init_msg *msg = calloc(1, size);
struct rfb_server_init_msg* msg = calloc(1, size);
if (!msg) {
client_unref(client);
return;
}
msg->width = htons(display->width),
msg->height = htons(display->height),
msg->name_length = htonl(name_len),
msg->height = htons(display->height), msg->name_length = htonl(name_len),
memcpy(msg->name_string, display->name, name_len);
int rc = rfb_pixfmt_from_fourcc(&msg->pixel_format, display->pixfmt);
@ -469,7 +471,7 @@ static void send_server_init_message(struct nvnc_client *client)
free(msg);
}
static int on_init_message(struct nvnc_client *client)
static int on_init_message(struct nvnc_client* client)
{
if (client->buffer_len - client->buffer_index < 1)
return 0;
@ -488,13 +490,13 @@ static int on_init_message(struct nvnc_client *client)
return sizeof(shared_flag);
}
static int on_client_set_pixel_format(struct nvnc_client *client)
static int on_client_set_pixel_format(struct nvnc_client* client)
{
if (client->buffer_len - client->buffer_index
< 4 + sizeof(struct rfb_pixel_format))
if (client->buffer_len - client->buffer_index <
4 + sizeof(struct rfb_pixel_format))
return 0;
struct rfb_pixel_format *fmt =
struct rfb_pixel_format* fmt =
(struct rfb_pixel_format*)(client->msg_buffer +
client->buffer_index + 4);
@ -515,9 +517,9 @@ static int on_client_set_pixel_format(struct nvnc_client *client)
return 4 + sizeof(struct rfb_pixel_format);
}
static int on_client_set_encodings(struct nvnc_client *client)
static int on_client_set_encodings(struct nvnc_client* client)
{
struct rfb_client_set_encodings_msg *msg =
struct rfb_client_set_encodings_msg* msg =
(struct rfb_client_set_encodings_msg*)(client->msg_buffer +
client->buffer_index);
@ -545,7 +547,7 @@ static int on_client_set_encodings(struct nvnc_client *client)
return sizeof(*msg) + 4 * n_encodings;
}
static void process_fb_update_requests(struct nvnc_client *client)
static void process_fb_update_requests(struct nvnc_client* client)
{
if (!client->server->frame)
return;
@ -564,11 +566,11 @@ static void process_fb_update_requests(struct nvnc_client *client)
schedule_client_update_fb(client);
}
static int on_client_fb_update_request(struct nvnc_client *client)
static int on_client_fb_update_request(struct nvnc_client* client)
{
struct nvnc *server = client->server;
struct nvnc* server = client->server;
struct rfb_client_fb_update_req_msg *msg =
struct rfb_client_fb_update_req_msg* msg =
(struct rfb_client_fb_update_req_msg*)(client->msg_buffer +
client->buffer_index);
@ -584,8 +586,8 @@ static int on_client_fb_update_request(struct nvnc_client *client)
* updates. This avoids superfluous complexity.
*/
if (!incremental)
pixman_region_union_rect(&client->damage, &client->damage,
x, y, width, height);
pixman_region_union_rect(&client->damage, &client->damage, x, y,
width, height);
nvnc_fb_req_fn fn = server->fb_req_fn;
if (fn)
@ -596,11 +598,11 @@ static int on_client_fb_update_request(struct nvnc_client *client)
return sizeof(*msg);
}
static int on_client_key_event(struct nvnc_client *client)
static int on_client_key_event(struct nvnc_client* client)
{
struct nvnc *server = client->server;
struct nvnc* server = client->server;
struct rfb_client_key_event_msg *msg =
struct rfb_client_key_event_msg* msg =
(struct rfb_client_key_event_msg*)(client->msg_buffer +
client->buffer_index);
@ -614,11 +616,11 @@ static int on_client_key_event(struct nvnc_client *client)
return sizeof(*msg);
}
static int on_client_pointer_event(struct nvnc_client *client)
static int on_client_pointer_event(struct nvnc_client* client)
{
struct nvnc *server = client->server;
struct nvnc* server = client->server;
struct rfb_client_pointer_event_msg *msg =
struct rfb_client_pointer_event_msg* msg =
(struct rfb_client_pointer_event_msg*)(client->msg_buffer +
client->buffer_index);
@ -633,9 +635,9 @@ static int on_client_pointer_event(struct nvnc_client *client)
return sizeof(*msg);
}
static int on_client_cut_text(struct nvnc_client *client)
static int on_client_cut_text(struct nvnc_client* client)
{
struct rfb_client_cut_text_msg *msg =
struct rfb_client_cut_text_msg* msg =
(struct rfb_client_cut_text_msg*)(client->msg_buffer +
client->buffer_index);
@ -646,7 +648,7 @@ static int on_client_cut_text(struct nvnc_client *client)
return sizeof(*msg) + length;
}
static int on_client_message(struct nvnc_client *client)
static int on_client_message(struct nvnc_client* client)
{
if (client->buffer_len - client->buffer_index < 1)
return 0;
@ -673,7 +675,7 @@ static int on_client_message(struct nvnc_client *client)
return 0;
}
static int try_read_client_message(struct nvnc_client *client)
static int try_read_client_message(struct nvnc_client* client)
{
switch (client->state) {
case VNC_CLIENT_STATE_ERROR:
@ -693,12 +695,11 @@ static int try_read_client_message(struct nvnc_client *client)
return 0;
}
static void on_client_read(uv_stream_t *stream, ssize_t n_read,
const uv_buf_t *buf)
static void on_client_read(uv_stream_t* stream, ssize_t n_read,
const uv_buf_t* buf)
{
struct nvnc_client *client =
container_of((uv_tcp_t*)stream, struct nvnc_client,
stream_handle);
struct nvnc_client* client = container_of(
(uv_tcp_t*)stream, struct nvnc_client, stream_handle);
if (n_read == UV_EOF) {
client_unref(client);
@ -736,12 +737,12 @@ static void on_client_read(uv_stream_t *stream, ssize_t n_read,
client->buffer_index = 0;
}
static void on_connection(uv_stream_t *server_stream, int status)
static void on_connection(uv_stream_t* server_stream, int status)
{
struct nvnc *server = container_of((uv_tcp_t*)server_stream,
struct nvnc, tcp_handle);
struct nvnc* server =
container_of((uv_tcp_t*)server_stream, struct nvnc, tcp_handle);
struct nvnc_client *client = calloc(1, sizeof(*client));
struct nvnc_client* client = calloc(1, sizeof(*client));
if (!client)
return;
@ -778,13 +779,13 @@ static void on_connection(uv_stream_t *server_stream, int status)
client->state = VNC_CLIENT_STATE_WAITING_FOR_VERSION;
}
int vnc_server_init(struct nvnc *self, const char* address, int port)
int vnc_server_init(struct nvnc* self, const char* address, int port)
{
LIST_INIT(&self->clients);
uv_tcp_init(uv_default_loop(), &self->tcp_handle);
struct sockaddr_in addr = { 0 };
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(address);
addr.sin_port = htons(port);
@ -803,9 +804,9 @@ failure:
}
EXPORT
struct nvnc *nvnc_open(const char *address, uint16_t port)
struct nvnc* nvnc_open(const char* address, uint16_t port)
{
struct nvnc *self = calloc(1, sizeof(*self));
struct nvnc* self = calloc(1, sizeof(*self));
if (!self)
return NULL;
@ -815,7 +816,7 @@ struct nvnc *nvnc_open(const char *address, uint16_t port)
uv_tcp_init(uv_default_loop(), &self->tcp_handle);
struct sockaddr_in addr = { 0 };
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(address);
addr.sin_port = htons(port);
@ -833,27 +834,27 @@ failure:
}
EXPORT
void nvnc_close(struct nvnc *self)
void nvnc_close(struct nvnc* self)
{
struct nvnc_client *client;
struct nvnc_client* client;
if (self->frame)
nvnc_fb_unref(self->frame);
LIST_FOREACH(client, &self->clients, link)
LIST_FOREACH (client, &self->clients, link)
client_unref(client);
uv_unref((uv_handle_t*)&self->tcp_handle);
free(self);
}
static void free_write_buffer(uv_write_t *req, int status)
static void free_write_buffer(uv_write_t* req, int status)
{
struct vnc_write_request *rq = (struct vnc_write_request*)req;
struct vnc_write_request* rq = (struct vnc_write_request*)req;
free(rq->buffer.base);
}
enum rfb_encodings choose_frame_encoding(struct nvnc_client *client)
enum rfb_encodings choose_frame_encoding(struct nvnc_client* client)
{
for (int i = 0; i < client->n_encodings; ++i)
switch (client->encodings[i]) {
@ -867,11 +868,11 @@ enum rfb_encodings choose_frame_encoding(struct nvnc_client *client)
return -1;
}
void do_client_update_fb(uv_work_t *work)
void do_client_update_fb(uv_work_t* work)
{
struct fb_update_work *update = (void*)work;
struct nvnc_client *client = update->client;
const struct nvnc_fb *fb = update->fb;
struct fb_update_work* update = (void*)work;
struct nvnc_client* client = update->client;
const struct nvnc_fb* fb = update->fb;
enum rfb_encodings encoding = choose_frame_encoding(client);
assert(encoding != -1);
@ -891,18 +892,18 @@ void do_client_update_fb(uv_work_t *work)
}
}
void on_client_update_fb_done(uv_work_t *work, int status)
void on_client_update_fb_done(uv_work_t* work, int status)
{
(void)status;
struct fb_update_work *update = (void*)work;
struct nvnc_client *client = update->client;
struct nvnc *server = client->server;
struct vec *frame = &update->frame;
struct fb_update_work* update = (void*)work;
struct nvnc_client* client = update->client;
struct nvnc* server = client->server;
struct vec* frame = &update->frame;
if (!uv_is_closing((uv_handle_t*)&client->stream_handle))
vnc__write((uv_stream_t*)&client->stream_handle,
frame->data, frame->len, free_write_buffer);
vnc__write((uv_stream_t*)&client->stream_handle, frame->data,
frame->len, free_write_buffer);
client->is_updating = false;
client->n_pending_requests--;
@ -911,12 +912,12 @@ void on_client_update_fb_done(uv_work_t *work, int status)
client_unref(client);
}
int schedule_client_update_fb(struct nvnc_client *client)
int schedule_client_update_fb(struct nvnc_client* client)
{
struct nvnc_fb* fb = client->server->frame;
assert(fb);
struct fb_update_work *work = calloc(1, sizeof(*work));
struct fb_update_work* work = calloc(1, sizeof(*work));
if (!work)
return -1;
@ -955,10 +956,10 @@ pixfmt_failure:
}
EXPORT
int nvnc_feed_frame(struct nvnc *self, struct nvnc_fb *fb,
const struct pixman_region16 *damage)
int nvnc_feed_frame(struct nvnc* self, struct nvnc_fb* fb,
const struct pixman_region16* damage)
{
struct nvnc_client *client;
struct nvnc_client* client;
if (self->frame)
nvnc_fb_unref(self->frame);
@ -966,7 +967,7 @@ int nvnc_feed_frame(struct nvnc *self, struct nvnc_fb *fb,
self->frame = fb;
nvnc_fb_ref(self->frame);
LIST_FOREACH(client, &self->clients, link) {
LIST_FOREACH (client, &self->clients, link) {
if (uv_is_closing((uv_handle_t*)&client->stream_handle))
continue;
@ -982,51 +983,51 @@ int nvnc_feed_frame(struct nvnc *self, struct nvnc_fb *fb,
}
EXPORT
void nvnc_set_userdata(void *self, void *userdata)
void nvnc_set_userdata(void* self, void* userdata)
{
struct nvnc_common *common = self;
struct nvnc_common* common = self;
common->userdata = userdata;
}
EXPORT
void* nvnc_get_userdata(const void *self)
void* nvnc_get_userdata(const void* self)
{
const struct nvnc_common *common = self;
const struct nvnc_common* common = self;
return common->userdata;
}
EXPORT
void nvnc_set_key_fn(struct nvnc *self, nvnc_key_fn fn)
void nvnc_set_key_fn(struct nvnc* self, nvnc_key_fn fn)
{
self->key_fn = fn;
}
EXPORT
void nvnc_set_pointer_fn(struct nvnc *self, nvnc_pointer_fn fn)
void nvnc_set_pointer_fn(struct nvnc* self, nvnc_pointer_fn fn)
{
self->pointer_fn = fn;
}
EXPORT
void nvnc_set_fb_req_fn(struct nvnc *self, nvnc_fb_req_fn fn)
void nvnc_set_fb_req_fn(struct nvnc* self, nvnc_fb_req_fn fn)
{
self->fb_req_fn = fn;
}
EXPORT
void nvnc_set_new_client_fn(struct nvnc *self, nvnc_client_fn fn)
void nvnc_set_new_client_fn(struct nvnc* self, nvnc_client_fn fn)
{
self->new_client_fn = fn;
}
EXPORT
void nvnc_set_client_cleanup_fn(struct nvnc_client *self, nvnc_client_fn fn)
void nvnc_set_client_cleanup_fn(struct nvnc_client* self, nvnc_client_fn fn)
{
self->cleanup_fn = fn;
}
EXPORT
void nvnc_set_dimensions(struct nvnc *self, uint16_t width, uint16_t height,
void nvnc_set_dimensions(struct nvnc* self, uint16_t width, uint16_t height,
uint32_t fourcc_format)
{
self->display.width = width;
@ -1035,13 +1036,13 @@ void nvnc_set_dimensions(struct nvnc *self, uint16_t width, uint16_t height,
}
EXPORT
struct nvnc *nvnc_get_server(const struct nvnc_client *client)
struct nvnc* nvnc_get_server(const struct nvnc_client* client)
{
return client->server;
}
EXPORT
void nvnc_set_name(struct nvnc *self, const char *name)
void nvnc_set_name(struct nvnc* self, const char* name)
{
strncpy(self->display.name, name, sizeof(self->display.name));
self->display.name[sizeof(self->display.name) - 1] = '\0';

8
src/util.c
View File

@ -20,18 +20,18 @@
#include <stdlib.h>
#include <unistd.h>
static void on_write_req_done(uv_write_t *req, int status)
static void on_write_req_done(uv_write_t* req, int status)
{
struct vnc_write_request *self = (struct vnc_write_request*)req;
struct vnc_write_request* self = (struct vnc_write_request*)req;
if (self->on_done)
self->on_done(req, status);
free(self);
}
int vnc__write(uv_stream_t *stream, const void *payload, size_t size,
int vnc__write(uv_stream_t* stream, const void* payload, size_t size,
uv_write_cb on_done)
{
struct vnc_write_request *req = calloc(1, sizeof(*req));
struct vnc_write_request* req = calloc(1, sizeof(*req));
if (!req)
return -1;

78
src/zrle.c
View File

@ -36,7 +36,7 @@
#define UDIV_UP(a, b) (((a) + (b) - 1) / (b))
static inline int find_colour_in_palette(uint32_t *palette, int len,
static inline int find_colour_in_palette(uint32_t* palette, int len,
uint32_t colour)
{
for (int i = 0; i < len; ++i)
@ -46,7 +46,7 @@ static inline int find_colour_in_palette(uint32_t *palette, int len,
return -1;
}
int zrle_get_tile_palette(uint32_t *palette, const uint32_t *src, size_t length)
int zrle_get_tile_palette(uint32_t* palette, const uint32_t* src, size_t length)
{
int n = 0;
@ -67,10 +67,10 @@ int zrle_get_tile_palette(uint32_t *palette, const uint32_t *src, size_t length)
return n;
}
void zrle_encode_unichrome_tile(struct vec *dst,
const struct rfb_pixel_format *dst_fmt,
void zrle_encode_unichrome_tile(struct vec* dst,
const struct rfb_pixel_format* dst_fmt,
uint32_t colour,
const struct rfb_pixel_format *src_fmt)
const struct rfb_pixel_format* src_fmt)
{
int bytes_per_cpixel = dst_fmt->depth / 8;
@ -82,7 +82,7 @@ void zrle_encode_unichrome_tile(struct vec *dst,
dst->len += bytes_per_cpixel;
}
void encode_run_length(struct vec *dst, uint8_t index, int run_length)
void encode_run_length(struct vec* dst, uint8_t index, int run_length)
{
if (run_length == 1) {
vec_fast_append_8(dst, index);
@ -99,18 +99,17 @@ void encode_run_length(struct vec *dst, uint8_t index, int run_length)
vec_fast_append_8(dst, run_length - 1);
}
void zrle_encode_packed_tile(struct vec *dst,
const struct rfb_pixel_format *dst_fmt,
const uint32_t *src,
const struct rfb_pixel_format *src_fmt,
size_t length,
uint32_t *palette, int palette_size)
void zrle_encode_packed_tile(struct vec* dst,
const struct rfb_pixel_format* dst_fmt,
const uint32_t* src,
const struct rfb_pixel_format* src_fmt,
size_t length, uint32_t* palette, int palette_size)
{
int bytes_per_cpixel = dst_fmt->depth / 8;
uint8_t cpalette[16 * 3];
pixel32_to_cpixel((uint8_t*)cpalette, dst_fmt, palette,
src_fmt, bytes_per_cpixel, palette_size);
pixel32_to_cpixel((uint8_t*)cpalette, dst_fmt, palette, src_fmt,
bytes_per_cpixel, palette_size);
vec_fast_append_8(dst, 128 | palette_size);
@ -125,8 +124,7 @@ void zrle_encode_packed_tile(struct vec *dst,
continue;
}
index = find_colour_in_palette(palette, palette_size,
src[i - 1]);
index = find_colour_in_palette(palette, palette_size, src[i - 1]);
encode_run_length(dst, index, run_length);
run_length = 1;
}
@ -138,17 +136,16 @@ void zrle_encode_packed_tile(struct vec *dst,
}
}
void zrle_copy_tile(uint32_t *dst, const uint32_t *src, int stride,
int width, int height)
void zrle_copy_tile(uint32_t* dst, const uint32_t* src, int stride, int width,
int height)
{
for (int y = 0; y < height; ++y)
memcpy(dst + y * width, src + y * stride, width * 4);
}
void zrle_encode_tile(struct vec *dst, const struct rfb_pixel_format *dst_fmt,
const uint32_t *src,
const struct rfb_pixel_format *src_fmt,
size_t length)
void zrle_encode_tile(struct vec* dst, const struct rfb_pixel_format* dst_fmt,
const uint32_t* src,
const struct rfb_pixel_format* src_fmt, size_t length)
{
int bytes_per_cpixel = dst_fmt->depth / 8;
@ -176,8 +173,7 @@ void zrle_encode_tile(struct vec *dst, const struct rfb_pixel_format *dst_fmt,
dst->len += bytes_per_cpixel * length;
}
int zrle_deflate(struct vec* dst, const struct vec* src, z_stream* zs,
bool flush)
int zrle_deflate(struct vec* dst, const struct vec* src, z_stream* zs, bool flush)
{
int r = Z_STREAM_ERROR;
@ -202,18 +198,17 @@ int zrle_deflate(struct vec* dst, const struct vec* src, z_stream* zs,
return 0;
}
int zrle_encode_box(struct vec* out, const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *fb,
const struct rfb_pixel_format *src_fmt,
int x, int y, int stride, int width, int height,
z_stream* zs)
int zrle_encode_box(struct vec* out, const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* fb,
const struct rfb_pixel_format* src_fmt, int x, int y,
int stride, int width, int height, z_stream* zs)
{
int r = -1;
int bytes_per_cpixel = dst_fmt->depth / 8;
int chunk_size = 1 + bytes_per_cpixel * TILE_LENGTH * TILE_LENGTH;
struct vec in;
uint32_t *tile = malloc(TILE_LENGTH * TILE_LENGTH * 4);
uint32_t* tile = malloc(TILE_LENGTH * TILE_LENGTH * 4);
if (!tile)
goto failure;
@ -236,15 +231,17 @@ int zrle_encode_box(struct vec* out, const struct rfb_pixel_format *dst_fmt,
size_t size_index = out->len;
vec_append_zero(out, 4);
int n_tiles =
UDIV_UP(width, TILE_LENGTH) * UDIV_UP(height, TILE_LENGTH);
int n_tiles = UDIV_UP(width, TILE_LENGTH) * UDIV_UP(height, TILE_LENGTH);
for (int i = 0; i < n_tiles; ++i) {
int tile_x = (i % UDIV_UP(width, TILE_LENGTH)) * TILE_LENGTH;
int tile_y = (i / UDIV_UP(width, TILE_LENGTH)) * TILE_LENGTH;
int tile_width = width - tile_x >= TILE_LENGTH ? TILE_LENGTH : width - tile_x;
int tile_height = height - tile_y >= TILE_LENGTH ? TILE_LENGTH : height - tile_y;
int tile_width = width - tile_x >= TILE_LENGTH ? TILE_LENGTH
: width - tile_x;
int tile_height = height - tile_y >= TILE_LENGTH
? TILE_LENGTH
: height - tile_y;
int y_off = y + tile_y;
@ -270,17 +267,16 @@ failure:
#undef CHUNK
}
int zrle_encode_frame(z_stream *zs,
struct vec* dst,
const struct rfb_pixel_format *dst_fmt,
const struct nvnc_fb *src,
const struct rfb_pixel_format *src_fmt,
struct pixman_region16 *region)
int zrle_encode_frame(z_stream* zs, struct vec* dst,
const struct rfb_pixel_format* dst_fmt,
const struct nvnc_fb* src,
const struct rfb_pixel_format* src_fmt,
struct pixman_region16* region)
{
int rc = -1;
int n_rects = 0;
struct pixman_box16 *box = pixman_region_rectangles(region, &n_rects);
struct pixman_box16* box = pixman_region_rectangles(region, &n_rects);
if (n_rects > UINT16_MAX) {
box = pixman_region_extents(region);
n_rects = 1;