init xnum and ynum

[netwatch.git] / net / rfb.c

diff --git a/net/rfb.c b/net/rfb.c
index 4f272cc584608111e906e036daf45761d7d49bae..13f6fb47e81849aa4acd4de541c4cdbb12b0ebfd 100644 (file)
--- a/net/rfb.c
+++ b/net/rfb.c
@@ -3,7 +3,10 @@
 #include <output.h>
 #include <fb.h>
 
 #include <output.h>
 #include <fb.h>
 

+#include "../aseg-paging/keyboard.h"
+

 #include "lwip/tcp.h"
 #include "lwip/tcp.h"

+#include "lwip/stats.h"

 
 #include "rfb.h"
 
 
 #include "rfb.h"
 


@@ -14,7 +17,10 @@
 #define POINTER_EVENT          5
 #define CLIENT_CUT_TEXT                6
 
 #define POINTER_EVENT          5
 #define CLIENT_CUT_TEXT                6
 

-#define RFB_BUF_SIZE   64
+#define RFB_BUF_SIZE   512
+
+#define SCREEN_CHUNKS_X 8      
+#define SCREEN_CHUNKS_Y 8

 
 struct pixel_format {
        uint8_t bpp;
 
 struct pixel_format {
        uint8_t bpp;


@@ -75,6 +81,17 @@ struct text_event_pkt {
        char text[];
 };
 
        char text[];
 };
 

+struct update_header {
+       uint8_t msgtype;
+       uint8_t padding;
+       uint16_t nrects;
+       uint16_t xpos;
+       uint16_t ypos;
+       uint16_t width;
+       uint16_t height;
+       int32_t enctype;
+};
+

 struct rfb_state {
        enum {
                ST_BEGIN,
 struct rfb_state {
        enum {
                ST_BEGIN,


@@ -89,10 +106,28 @@ struct rfb_state {
        int writepos;
 
        char next_update_incremental;
        int writepos;
 
        char next_update_incremental;

+       char update_requested;
+

        struct fb_update_req client_interest_area;
 
        struct fb_update_req client_interest_area;
 

-       uint8_t needs_updated;
-       uint8_t sending;
+       enum {
+               SST_IDLE,
+               SST_HEADER,
+               SST_DATA
+       } send_state;
+
+       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;
+
+       uint32_t chunk_actually_sent;

 };
 
 static struct server_init_message server_info;
 };
 
 static struct server_init_message server_info;


@@ -129,8 +164,179 @@ static void update_server_info() {
        }
 }
 
        }
 }
 

-static void start_send(struct tcp_pcb *pcb, struct rfb_state *state) {
-       /* ... */
+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;
+       unsigned char * lptr;
+       uint32_t checksum;
+       int totaldim;
+       err_t err;
+
+       while(1) {
+
+               switch (state->send_state) {
+
+               case SST_IDLE:
+                       /* Nothing to do */
+
+                       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);
+                       }
+
+                       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);
+                       }
+
+                       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;
+                               }
+                       }
+
+                       outputf("actually sent");
+                       state->chunk_actually_sent = 1;
+
+                       /* 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);
+
+                               /* Try again later. */
+                               return;
+                       }
+
+                       state->send_state = SST_DATA;
+
+                       /* FALL THROUGH to SST_DATA */
+
+               case SST_DATA:
+
+                       lines_left = state->chunk_height - state->chunk_lindex;
+
+                       if (lines_left == 0) {
+                               state->send_state = SST_HEADER;
+                               if (advance_chunk(state))
+                                       return;
+                               break;
+                       }
+
+                       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;
+                       } else {
+                               if (err != ERR_MEM)
+                                       outputf("RFB: send error %d", err);
+
+                               return;
+                       }
+                               
+                       if (tcp_sndbuf(pcb) == 0) {
+                               return;
+                       }
+               }
+       }
+       
+       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) {
+       struct rfb_state *state = arg;
+       send_fsm(pcb, state);
+       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) {
 }
 
 static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {


@@ -204,7 +410,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                state->state = ST_MAIN;
 
                outputf("RFB: Sending server info", state->version);
                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;
                tcp_output(pcb);
 
                return OK;


@@ -242,7 +448,6 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                        for (i = 0; i < ntohs(req->num); i++) {
                                outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
                                /* XXX ... */
                        for (i = 0; i < ntohs(req->num); i++) {
                                outputf("RFB: Encoding: %d", ntohl(req->encodings[i]));
                                /* XXX ... */

-

                        }
 
                        state->readpos += pktsize;
                        }
 
                        state->readpos += pktsize;


@@ -253,7 +458,7 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                                return NEEDMORE;
                        outputf("RFB: UpdateRequest");
 
                                return NEEDMORE;
                        outputf("RFB: UpdateRequest");
 

-                       state->needs_updated = 1;
+                       state->update_requested = 1;

                        memcpy(&state->client_interest_area, state->data,
                               sizeof(struct fb_update_req)); 
 
                        memcpy(&state->client_interest_area, state->data,
                               sizeof(struct fb_update_req)); 
 


@@ -263,9 +468,11 @@ static enum fsm_result recv_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                case KEY_EVENT:
                        if (state->writepos < sizeof(struct key_event_pkt))
                                return NEEDMORE;
                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;
 
                        state->readpos += sizeof(struct key_event_pkt);
                        return OK;


@@ -289,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)
                                (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)
                                return NEEDMORE;
 
                        /* XXX stub */
 
                        state->readpos += sizeof(struct text_event_pkt)

-                                         + pkt->length;
+                                         + pkt->length;

                        return OK;
 
                default:
                        return OK;
 
                default:


@@ -308,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,
 }
 
 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) 
        struct rfb_state *state = arg;
 
        if (state == NULL) 


@@ -349,9 +556,10 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
                case OK:
                        outputf("RFB FSM: ok");
 
                case OK:
                        outputf("RFB FSM: ok");
 

-                       /* Might as well send now... */
-                       if (state->needs_updated && !state->sending) {
-                               start_send(pcb, state);
+                       /* Kick off a send. */
+                       if (state->send_state == SST_IDLE
+                           && state->update_requested) {
+                               send_fsm(pcb, state);

                        }
 
                        if (state->readpos == state->writepos) {
                        }
 
                        if (state->readpos == state->writepos) {


@@ -360,8 +568,8 @@ static err_t rfb_recv(void *arg, struct tcp_pcb *pcb,
                                return ERR_OK;
                        } else {
                                memmove(state->data,
                                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:
                        }
                        break;
                case FAIL:


@@ -384,8 +592,11 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
        state->state = ST_BEGIN;
        state->readpos = 0;
        state->writepos = 0;
        state->state = ST_BEGIN;
        state->readpos = 0;
        state->writepos = 0;

-       state->needs_updated = 0;
-       state->sending = 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. */
 
        /* XXX: update_server_info() should be called from the 64ms timer, and deal
         * with screen resizes appropriately. */


@@ -399,9 +610,10 @@ static err_t rfb_accept(void *arg, struct tcp_pcb *pcb, err_t err) {
 
        tcp_arg(pcb, state);
        tcp_recv(pcb, rfb_recv);
 
        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_err(pcb, rfb_err);

-       tcp_poll(pcb, rfb_poll, 2);

 */
        tcp_write(pcb, "RFB 003.008\n", 12, 0);
        tcp_output(pcb);
 */
        tcp_write(pcb, "RFB 003.008\n", 12, 0);
        tcp_output(pcb);