#include <output.h>
#include <fb.h>
+#include "../aseg-paging/keyboard.h"
+
#include "lwip/tcp.h"
+#include "lwip/stats.h"
#include "rfb.h"
#define POINTER_EVENT 5
#define CLIENT_CUT_TEXT 6
-#define RFB_BUF_SIZE 64
+#define RFB_BUF_SIZE 512
+
+#define SCREEN_CHUNKS_X 4
+#define SCREEN_CHUNKS_Y 8
struct pixel_format {
uint8_t bpp;
SST_SENDING
} send_state;
- uint32_t update_pos;
- uint32_t frame_bytes;
+ uint32_t checksums[SCREEN_CHUNKS_X][SCREEN_CHUNKS_Y];
+
+ uint32_t chunk_xnum;
+ uint32_t chunk_ynum;
+ uint32_t chunk_xpos;
+ uint32_t chunk_ypos;
+ uint32_t chunk_width;
+ uint32_t chunk_height;
+
+ uint32_t chunk_lindex;
};
static struct server_init_message server_info;
static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
struct update_header hdr;
- int left, sndlength;
+ int lines_left;
+ char * lptr;
+ uint32_t checksum;
+ int totaldim;
err_t err;
switch (state->send_state) {
break;
}
- /* potential FALL THROUGH */
+ /* FALL THROUGH to SST_NEEDS_UPDATE */
case SST_NEEDS_UPDATE:
- outputf("RFB send: sending header");
- /* Send a header */
- state->frame_bytes = fb->curmode.xres * fb->curmode.yres * 3; /* XXX */
- hdr.msgtype = 0;
- hdr.nrects = htons(1);
- hdr.xpos = htons(0);
- hdr.ypos = htons(0);
- hdr.width = htons(fb->curmode.xres);
- hdr.height = htons(fb->curmode.yres);
- hdr.enctype = htonl(0);
- tcp_write(pcb, &hdr, sizeof(hdr), 0);
- tcp_output(pcb);
- state->update_pos = 0;
+ 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;
- /* FALL THROUGH */
+ /* FALL THROUGH to SST_SENDING */
case SST_SENDING:
- left = state->frame_bytes - state->update_pos;
-
- if (left > tcp_sndbuf(pcb)) {
- sndlength = tcp_sndbuf(pcb);
- } else {
- sndlength = left;
- }
- do {
- err = tcp_write(pcb, fb->fbaddr + state->update_pos, sndlength, 0);
- if (err == ERR_MEM) {
- outputf("RFB: ERR_MEM sending %d", sndlength);
- sndlength /= 2;
+ while (1) {
+ lines_left = state->chunk_height - state->chunk_lindex;
+
+ if (lines_left == 0) {
+ /* 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. */
+
+ if (state->chunk_height != 0) {
+ 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->send_state = SST_IDLE;
+ outputf("RFB: Screen update done! %d", state->update_requested);
+ break;
+ }
+
+ /* 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);
+ }
+
+ 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);
+ }
+
+ 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]) {
+ state->chunk_lindex = state->chunk_height;
+ continue;
+ } else {
+ state->checksums[state->chunk_xnum][state->chunk_ynum] = checksum;
+ }
+ }
+/*
+ outputf("RFB send: sending header");
+*/
+ /* 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;
+
+ 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;
+ }
}
- } while (err == ERR_MEM && sndlength > 1);
- if (err == ERR_OK) {
- outputf("RFB: sent %d", sndlength);
- state->update_pos += sndlength;
- } else {
- outputf("RFB: send error %d", err);
- }
+ do {
+ lptr = fb->fbaddr
+ + (fb->curmode.xres * fb->curmode.bytestride
+ * (state->chunk_ypos + state->chunk_lindex))
+ + (state->chunk_xpos * fb->curmode.bytestride);
- tcp_output(pcb);
+ /* 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;
+ }
+
+ } while (err == ERR_OK && state->chunk_lindex < state->chunk_height);
- if (state->update_pos == state->frame_bytes) {
- state->send_state = SST_IDLE;
+ if (err != ERR_OK) {
+ if (err != ERR_MEM)
+ outputf("RFB: send error %d", err);
+
+ break;
+ }
+
+ if (tcp_sndbuf(pcb) == 0) {
+ break;
+ }
}
break;
}
+
+ if (tcp_output(pcb) != ERR_OK)
+ outputf("RFB: tcp_output bailed in send_fsm?");
}
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;
+ state->update_requested = 1;
+ 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);
state->state = ST_MAIN;
outputf("RFB: Sending server info", state->version);
- tcp_write(pcb, &server_info, sizeof(server_info), 0);
+ tcp_write(pcb, &server_info, sizeof(server_info), TCP_WRITE_FLAG_COPY);
tcp_output(pcb);
return OK;
for (i = 0; i < ntohs(req->num); i++) {
outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
/* XXX ... */
-
}
state->readpos += pktsize;
case KEY_EVENT:
if (state->writepos < sizeof(struct key_event_pkt))
return NEEDMORE;
- outputf("RFB: Key");
- /* XXX stub */
+ struct key_event_pkt * p = (struct key_event_pkt *)state->data;
+
+ outputf("RFB: Key: %d (%c)", htonl(p->keysym), (htonl(p->keysym) & 0xFF));
+ kbd_inject_keysym(htonl(p->keysym), p->downflag);
state->readpos += sizeof(struct key_event_pkt);
return OK;
case OK:
outputf("RFB FSM: ok");
- /* Might as well send now... */
+ /* Kick off a send. */
if (state->send_state == SST_IDLE
&& state->update_requested) {
send_fsm(pcb, state);
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);
git.joshuawise.com / netwatch.git / blobdiff