X-Git-Url: http://git.joshuawise.com/netwatch.git/blobdiff_plain/b496c2b16e66ba34a8725fb49a1bf27f0588939c..9eee8073b16fad5359206bb7d832293ce878dd16:/net/rfb.c

diff --git a/net/rfb.c b/net/rfb.c
index 5fe1a11..13f6fb4 100644
--- a/net/rfb.c
+++ b/net/rfb.c
@@ -6,6 +6,7 @@
 #include "../aseg-paging/keyboard.h"
 
 #include "lwip/tcp.h"
+#include "lwip/stats.h"
 
 #include "rfb.h"
 
@@ -16,9 +17,9 @@
 #define POINTER_EVENT		5
 #define CLIENT_CUT_TEXT		6
 
-#define RFB_BUF_SIZE	64
+#define RFB_BUF_SIZE	512
 
-#define SCREEN_CHUNKS_X	16
+#define SCREEN_CHUNKS_X 8	
 #define SCREEN_CHUNKS_Y 8
 
 struct pixel_format {
@@ -111,11 +112,11 @@ struct rfb_state {
 
 	enum {
 		SST_IDLE,
-		SST_NEEDS_UPDATE,
-		SST_SENDING
+		SST_HEADER,
+		SST_DATA
 	} send_state;
 
-	uint32_t checksums[SCREEN_CHUNKS_Y][SCREEN_CHUNKS_X];
+	uint32_t checksums[SCREEN_CHUNKS_X][SCREEN_CHUNKS_Y];
 
 	uint32_t chunk_xnum;
 	uint32_t chunk_ynum;
@@ -125,6 +126,8 @@ struct rfb_state {
 	uint32_t chunk_height;
 
 	uint32_t chunk_lindex;
+
+	uint32_t chunk_actually_sent;
 };
 
 static struct server_init_message server_info;
@@ -161,155 +164,160 @@ static void update_server_info() {
 	}
 }
 
+static int advance_chunk(struct rfb_state *state) {
+
+	state->chunk_xnum += 1;
+
+	if (state->chunk_xnum == SCREEN_CHUNKS_X) {
+		state->chunk_ynum += 1;
+		state->chunk_xnum = 0;
+	}
+
+	if (state->chunk_ynum == SCREEN_CHUNKS_Y) {
+		state->chunk_ynum = 0;
+		state->send_state = SST_IDLE;
+		if (!(state->chunk_actually_sent))
+			state->update_requested = 1;
+			return 1;
+	}
+
+	return 0;
+}
+
 static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
 	struct update_header hdr;
 	int lines_left;
-	char * lptr;
+	unsigned char * lptr;
+	uint32_t checksum;
 	int totaldim;
 	err_t err;
 
-	switch (state->send_state) {
-	case SST_IDLE:
-		/* Nothing to do */
-		if (state->update_requested) {
-			outputf("RFB send: update requested");
-			state->update_requested = 0;
-			state->send_state = SST_NEEDS_UPDATE;
-		} else {
-			break;
-		}
-	
-		/* FALL THROUGH to SST_NEEDS_UPDATE */
+	while(1) {
 
-	case SST_NEEDS_UPDATE:
+		switch (state->send_state) {
 
-		state->chunk_xnum = 0;
-		state->chunk_ynum = 0;
-		state->chunk_width = 0;
-		state->chunk_height = 0;
-		state->chunk_lindex = 0;
-		state->send_state = SST_SENDING;
+		case SST_IDLE:
+			/* Nothing to do */
 
-		/* FALL THROUGH to SST_SENDING */
+			if (state->update_requested) {
+				outputf("RFB send: update requested");
+				state->update_requested = 0;
+				state->chunk_actually_sent = 0;
+				state->send_state = SST_HEADER;
+			} else {
+				return;
+			}
+	
+			/* FALL THROUGH to SST_HEADER */
+
+		case SST_HEADER:
+
+			/* Calculate the width and height for this chunk, remembering
+			 * that if SCREEN_CHUNKS_[XY] do not evenly divide the width and
+			 * height, we may need to have shorter chunks at the edge of
+			 * the screen. */
+
+			state->chunk_width = fb->curmode.xres / SCREEN_CHUNKS_X;
+			if (fb->curmode.xres % SCREEN_CHUNKS_X != 0)
+				state->chunk_width += 1;
+			state->chunk_xpos = state->chunk_width * state->chunk_xnum;
+			totaldim = state->chunk_width * (state->chunk_xnum + 1);
+			if (totaldim > fb->curmode.xres) {
+				state->chunk_width -= (totaldim - fb->curmode.xres);
+			}
 
-	case SST_SENDING:
+			state->chunk_height = fb->curmode.yres / SCREEN_CHUNKS_Y;
+			if (fb->curmode.yres % SCREEN_CHUNKS_Y != 0)
+				state->chunk_height += 1;
+			state->chunk_ypos = state->chunk_height
+						 * state->chunk_ynum;
+			totaldim = state->chunk_height * (state->chunk_ynum + 1);
+			if (totaldim > fb->curmode.yres) {
+				state->chunk_height -= (totaldim - fb->curmode.yres);
+			}
 
-		while (1) {
-			lines_left = state->chunk_height - state->chunk_lindex;
+			outputf("rfb send: (%d [%d], %d [%d]) %d x %d",
+				state->chunk_xnum, state->chunk_xpos,
+				state->chunk_ynum, state->chunk_ypos,
+				state->chunk_width, state->chunk_height);
+
+			/* Do we _actually_ need to send this chunk? */
+			if (fb->checksum_rect) {
+				checksum = fb->checksum_rect(state->chunk_xpos, state->chunk_ypos,
+						     state->chunk_width, state->chunk_height);
+
+				if (checksum == state->checksums[state->chunk_xnum][state->chunk_ynum]) {
+					outputf("!!!!!!! SKIPPING: %08x", checksum);
+					if (advance_chunk(state))
+						return;
+					continue;
+				} else {
+					state->checksums[state->chunk_xnum][state->chunk_ynum] = checksum;
+				}
+			}
 
-			if (lines_left == 0) {
-				outputf("RFB: (%d [%d], %d [%d]), advancing",
-					state->chunk_xnum, state->chunk_xpos,
-					state->chunk_ynum, state->chunk_ypos);
+			outputf("actually sent");
+			state->chunk_actually_sent = 1;
 
-				/* Advance to the next chunk if necessary. If
-				 * state->chunk_height is zero, then we are
-				 * arriving here for the first time from
-				 * SST_NEEDS_UPDATE. */
+			/* Send a header */
+			hdr.msgtype = 0;
+			state->chunk_lindex = 0;
+			hdr.nrects = htons(1);
+			hdr.xpos = htons(state->chunk_xpos);
+			hdr.ypos = htons(state->chunk_ypos);
+			hdr.width = htons(state->chunk_width);
+			hdr.height= htons(state->chunk_height);
+			hdr.enctype = htonl(0);
+			lines_left = state->chunk_height;
 
-				if (state->chunk_height != 0) {
-					state->chunk_xnum += 1;
-				}
+			err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);
 
-				if (state->chunk_xnum == SCREEN_CHUNKS_X) {
-					state->chunk_ynum += 1;
-					state->chunk_xnum = 0;
-				}
+			if (err != ERR_OK) {
+				if (err != ERR_MEM)
+					outputf("RFB: header send error %d", err);
 
-				if (state->chunk_ynum == SCREEN_CHUNKS_Y) {
-					state->send_state = SST_IDLE;
-					break;
-				}
+				/* Try again later. */
+				return;
+			}
 
-				outputf("RFB send: sending header");
+			state->send_state = SST_DATA;
 
-				/* Calculate the width and height for this chunk, remembering
-				 * that if SCREEN_CHUNKS_[XY] do not evenly divide the width and
-				 * height, we may need to have shorter chunks at the edge of
-				 * the screen. */
+			/* FALL THROUGH to SST_DATA */
 
-				state->chunk_width = fb->curmode.xres / SCREEN_CHUNKS_X;
-				if (fb->curmode.xres % SCREEN_CHUNKS_X != 0)
-					state->chunk_width += 1;
-				state->chunk_xpos = state->chunk_width * state->chunk_xnum;
-				totaldim = state->chunk_width * (state->chunk_xnum + 1);
-				if (totaldim > fb->curmode.xres) {
-					state->chunk_width -= (totaldim - fb->curmode.xres);
-				}
+		case SST_DATA:
 
-				state->chunk_height = fb->curmode.yres / SCREEN_CHUNKS_Y;
-				if (fb->curmode.yres % SCREEN_CHUNKS_Y != 0)
-					state->chunk_height += 1;
-				state->chunk_ypos = state->chunk_height
-				                         * state->chunk_ynum;
-				totaldim = state->chunk_height * (state->chunk_ynum + 1);
-				if (totaldim > fb->curmode.yres) {
-					state->chunk_height -= (totaldim - fb->curmode.yres);
-				}
+			lines_left = state->chunk_height - state->chunk_lindex;
 
-				/* Send a header */
-				hdr.msgtype = 0;
-				hdr.nrects = htons(1);
-				hdr.xpos = htons(state->chunk_xpos);
-				hdr.ypos = htons(state->chunk_ypos);
-				hdr.width = htons(state->chunk_width);
-				hdr.height= htons(state->chunk_height);
-				hdr.enctype = htonl(0);
-				state->chunk_lindex = 0;
-				lines_left = state->chunk_height;
-
-				err = tcp_write(pcb, &hdr, sizeof(hdr), TCP_WRITE_FLAG_COPY);
-
-				if (err != ERR_OK) {
-					if (err != ERR_MEM)
-						outputf("RFB: header send error %d", err);
-
-					/* Crap. Reset chunk_height to 0 so that next time around,
-					 * we'll recalculate this chunk (not advance) and try to
-					 * send the header again. 
-					 */
-					state->chunk_height = 0;
-				}
+			if (lines_left == 0) {
+				state->send_state = SST_HEADER;
+				if (advance_chunk(state))
+					return;
+				break;
 			}
 
-			do {
-				outputf("RFB: (%d [%d], %d [%d]), %d x %d, line %d",
-					state->chunk_xnum, state->chunk_xpos,
-					state->chunk_ynum, state->chunk_ypos,
-					state->chunk_width, state->chunk_height,
-					state->chunk_lindex);
-
-				lptr = fb->fbaddr
-					+ (fb->curmode.xres * fb->curmode.bytestride
-					   * (state->chunk_ypos + state->chunk_lindex))
-					+ (state->chunk_xpos * fb->curmode.bytestride);
-
-				/* The network card can't DMA from video RAM,
-				 * so use TCP_WRITE_FLAG_COPY. */
-				err = tcp_write(pcb, lptr,
-					fb->curmode.bytestride * state->chunk_width,
-					TCP_WRITE_FLAG_COPY);
-
-				if (err == ERR_OK) {
-					state->chunk_lindex += 1;
-				}
+			lptr = fb->fbaddr
+				+ (fb->curmode.xres * fb->curmode.bytestride
+				   * (state->chunk_ypos + state->chunk_lindex))
+				+ (state->chunk_xpos * fb->curmode.bytestride);
 
-			} while (err == ERR_OK && state->chunk_lindex < state->chunk_height);
+			/* The network card can't DMA from video RAM,
+			 * so use TCP_WRITE_FLAG_COPY. */
+			err = tcp_write(pcb, lptr,
+				fb->curmode.bytestride * state->chunk_width, TCP_WRITE_FLAG_COPY);
 
-			if (err != ERR_OK) {
+			if (err == ERR_OK) {
+				state->chunk_lindex += 1;
+			} else {
 				if (err != ERR_MEM)
 					outputf("RFB: send error %d", err);
 
-				outputf("RFB: that's all for now");
-				break;
+				return;
 			}
 				
 			if (tcp_sndbuf(pcb) == 0) {
-				break;
+				return;
 			}
 		}
-
-		break;
 	}
 	
 	if (tcp_output(pcb) != ERR_OK)
@@ -322,6 +330,15 @@ static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
 	return ERR_OK;
 }
 
+static err_t rfb_poll(void *arg, struct tcp_pcb *pcb) {
+	struct rfb_state *state = arg;
+	send_fsm(pcb, state);
+/*
+	stats_display();
+*/
+	return ERR_OK;
+}
+
 static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
 	tcp_arg(pcb, NULL);
 	tcp_sent(pcb, NULL);
@@ -479,13 +496,13 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
 				(struct text_event_pkt *)state->data;
 
 			if (state->writepos < sizeof(struct text_event_pkt)
-			                      + pkt->length)
+					      + pkt->length)
 				return NEEDMORE;
 
 			/* XXX stub */
 
 			state->readpos += sizeof(struct text_event_pkt)
-			                  + pkt->length;
+					  + pkt->length;
 			return OK;
 
 		default:
@@ -498,7 +515,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
 }
 
 static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
-                      struct pbuf *p, err_t err) {
+		      struct pbuf *p, err_t err) {
 	struct rfb_state *state = arg;
 
 	if (state == NULL) 
@@ -551,8 +568,8 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
 				return ERR_OK;
 			} else {
 				memmove(state->data,
-				        state->data + state->readpos,
-				        state->writepos - state->readpos);
+					state->data + state->readpos,
+					state->writepos - state->readpos);
 			}
 			break;
 		case FAIL:
@@ -577,6 +594,9 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
 	state->writepos = 0;
 	state->update_requested = 0;
 	state->send_state = SST_IDLE;
+	state->chunk_xnum = 0;
+	state->chunk_ynum = 0;
+	memset(state->checksums, 0, sizeof(state->checksums));
 
 	/* XXX: update_server_info() should be called from the 64ms timer, and deal
 	 * with screen resizes appropriately. */
@@ -591,9 +611,9 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
 	tcp_arg(pcb, state);
 	tcp_recv(pcb, rfb_recv);
 	tcp_sent(pcb, rfb_sent);
+	tcp_poll(pcb, rfb_poll, 1);
 /*
 	tcp_err(pcb, rfb_err);
-	tcp_poll(pcb, rfb_poll, 2);
 */
 	tcp_write(pcb, "RFB 003.008\n", 12, 0);
 	tcp_output(pcb);