#define POINTER_EVENT 5
#define CLIENT_CUT_TEXT 6
-#define RFB_BUF_SIZE 512
+#define RFB_BUF_SIZE 1536
-#define SCREEN_CHUNKS_X 8
+#define SCREEN_CHUNKS_X 8
#define SCREEN_CHUNKS_Y 8
struct pixel_format {
uint32_t chunk_width;
uint32_t chunk_height;
- uint32_t chunk_lindex;
+ uint32_t chunk_bytes_sent;
uint32_t chunk_checksum;
int chunk_actually_sent;
int try_in_a_bit;
+
+ char * blockbuf;
};
static struct server_init_message server_info;
state->chunk_ynum = 0;
state->send_state = SST_IDLE;
if (!(state->chunk_actually_sent))
- state->try_in_a_bit = 2;
+ state->try_in_a_bit = 1;
return 1;
}
return 0;
}
+static int ceildiv(int a, int b) {
+ int res = a / b;
+ if (a % b != 0) {
+ res++;
+ }
+ return res;
+}
+
static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
struct update_header hdr;
- int lines_left;
- unsigned char * lptr;
+ int bytes_left;
int totaldim;
err_t err;
* 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_width = ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X);
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_height = ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y);
state->chunk_ypos = state->chunk_height
* state->chunk_ynum;
totaldim = state->chunk_height * (state->chunk_ynum + 1);
/* Checksum gets set in data block, AFTER the data has been sent. */
}
- outputf("actually sent");
state->chunk_actually_sent = 1;
/* Send a header */
hdr.msgtype = 0;
- state->chunk_lindex = 0;
+ state->chunk_bytes_sent = 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);
state->send_state = SST_DATA;
+ /* Snag the data. */
+ fb->copy_pixels(state->blockbuf,
+ state->chunk_xpos, state->chunk_ypos,
+ state->chunk_width, state->chunk_height);
+
/* FALL THROUGH to SST_DATA */
case SST_DATA:
- lines_left = state->chunk_height - state->chunk_lindex;
+ bytes_left = 4 * state->chunk_width * state->chunk_height - state->chunk_bytes_sent;
- if (lines_left == 0) {
+ if (bytes_left == 0) {
state->send_state = SST_HEADER;
state->checksums[state->chunk_xnum][state->chunk_ynum] = state->chunk_checksum;
if (advance_chunk(state))
break;
}
- lptr = fb->fbaddr
- + (fb->curmode.xres * fb->curmode.bytestride
- * (state->chunk_ypos + state->chunk_lindex))
- + (state->chunk_xpos * fb->curmode.bytestride);
+ /* That's enough. */
+ if (bytes_left > 1400) {
+ bytes_left = 1400;
+ }
- /* 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);
+ err = tcp_write(pcb, state->blockbuf + state->chunk_bytes_sent,
+ bytes_left, TCP_WRITE_FLAG_COPY);
if (err == ERR_OK) {
- state->chunk_lindex += 1;
+ state->chunk_bytes_sent += bytes_left;
} else {
if (err != ERR_MEM)
outputf("RFB: send error %d", err);
static err_t rfb_poll(void *arg, struct tcp_pcb *pcb) {
struct rfb_state *state = arg;
- send_fsm(pcb, state);
if (state->try_in_a_bit) {
state->try_in_a_bit--;
if (!(state->try_in_a_bit)) {
state->update_requested = 1;
}
}
+ send_fsm(pcb, state);
/*
stats_display();
*/
tcp_arg(pcb, NULL);
tcp_sent(pcb, NULL);
tcp_recv(pcb, NULL);
+ mem_free(state->blockbuf);
mem_free(state);
tcp_close(pcb);
outputf("close_conn: done");
static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
int i;
int pktsize;
-
+/*
outputf("RFB FSM: st %d rp %d wp %d", state->state, state->readpos,
state->writepos);
-
+*/
switch(state->state) {
case ST_BEGIN:
if (state->writepos < 12) return NEEDMORE;
case ST_MAIN:
if (state->writepos < 1) return NEEDMORE;
- outputf("RFB: cmd %d", state->data[0]);
switch (state->data[0]) {
case SET_PIXEL_FORMAT:
}
copylen = pbuf_copy_partial(p, state->data + state->writepos, p->tot_len, 0);
+
outputf("RFB: Processing %d, wp %d, cp %d", p->tot_len, state->writepos, copylen);
+
state->writepos += p->tot_len;
tcp_recved(pcb, p->tot_len);
goto doneprocessing;
case OK:
- outputf("RFB FSM: ok");
-
if (state->readpos == state->writepos) {
state->readpos = 0;
state->writepos = 0;
static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
struct rfb_state *state;
+ char * blockbuf;
LWIP_UNUSED_ARG(arg);
LWIP_UNUSED_ARG(err);
state = (struct rfb_state *)mem_malloc(sizeof(struct rfb_state));
+ if (!state)
+ {
+ outputf("rfb_accept: out of memory\n");
+ return ERR_MEM;
+ }
+
memset(state, 0, sizeof(struct rfb_state));
+ blockbuf = mem_malloc(ceildiv(fb->curmode.xres, SCREEN_CHUNKS_X)
+ * ceildiv(fb->curmode.yres, SCREEN_CHUNKS_Y) * 4);
+
+ if (!blockbuf)
+ {
+ outputf("rfb_accept: out of memory allocating blockbuf\n");
+ mem_free(state);
+ return ERR_MEM;
+ }
+
+ state->blockbuf = blockbuf;
state->state = ST_BEGIN;
state->send_state = SST_IDLE;
* with screen resizes appropriately. */
update_server_info();
- if (!state)
- {
- outputf("rfb_accept: out of memory\n");
- return ERR_MEM;
- }
-
tcp_arg(pcb, state);
tcp_recv(pcb, rfb_recv);
tcp_sent(pcb, rfb_sent);
git.joshuawise.com / netwatch.git / blobdiff