move init to new stack

[netwatch.git] / net / rfb.c

diff --git a/net/rfb.c b/net/rfb.c
index ff0f0895b6bff8548b5c81c7a8263e3d703e6316..39efeff2355b7ea8f65d4fb154b197b40f903952 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 4      
+#define SCREEN_CHUNKS_Y 8

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


@@ -110,8 +116,16 @@ struct rfb_state {
                SST_SENDING
        } send_state;
 
                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 struct server_init_message server_info;


@@ -150,7 +164,10 @@ static void update_server_info() {
 
 static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
        struct update_header hdr;
 
 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) {
        err_t err;
 
        switch (state->send_state) {


@@ -164,66 +181,133 @@ static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
                        break;
                }
        
                        break;
                }
        

-               /* potential FALL THROUGH */
+               /* FALL THROUGH to SST_NEEDS_UPDATE */

 
        case SST_NEEDS_UPDATE:
 
        case SST_NEEDS_UPDATE:

-               outputf("RFB send: sending header");
-               /* Send a header */
-               state->frame_bytes = fb->curmode.xres * fb->curmode.yres * fb->curmode.bytestride;
-               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), TCP_WRITE_FLAG_COPY);
-
-               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;
 
                state->send_state = SST_SENDING;
 

-               /* FALL THROUGH */
+               /* FALL THROUGH to SST_SENDING */

 
        case SST_SENDING:
 
                while (1) {
 
        case SST_SENDING:
 
                while (1) {

-                       unsigned char mbuf[8192 /* XXX magic */];
-                       
-                       left = state->frame_bytes - state->update_pos;
+                       lines_left = state->chunk_height - state->chunk_lindex;

 
 

-                       if (left == 0) {
-                               state->send_state = SST_IDLE;
-                               break;
-                       }
-                       
-                       if (left > 8192)
-                               left = 8192;
+                       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 (left > tcp_mss(pcb)) {
-                               sndlength = tcp_mss(pcb);
-                       } else {
-                               sndlength = left;
+                               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;
+                               }

                        }
                        }

-                       
-                       memcpy(mbuf, fb->fbaddr + state->update_pos, sndlength);        /* It's OK if it becomes smaller later. */

 
                        do {
 
                        do {

-                               err = tcp_write(pcb, mbuf, sndlength, TCP_WRITE_FLAG_COPY /* This is my memory on the stack, thank you very much. */);
-                               if (err == ERR_MEM) {
-                                       outputf("RFB: ERR_MEM sending %d", sndlength);
-                                       sndlength /= 2;
+                               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;

                                }
                                }

-                       } while (err == ERR_MEM && sndlength > 1);

 
 

-                       if (err == ERR_OK) {
-                               outputf("RFB: attempting send %d", sndlength);
-                       } else {
-                               outputf("RFB: send error %d", err);
-                               break;
-                       }
+                       } while (err == ERR_OK && state->chunk_lindex < state->chunk_height);

 
 

-                       state->update_pos += sndlength;
+                       if (err != ERR_OK) {
+                               if (err != ERR_MEM)
+                                       outputf("RFB: send error %d", err);

 
 

+                               break;
+                       }
+                               

                        if (tcp_sndbuf(pcb) == 0) {
                                break;
                        }
                        if (tcp_sndbuf(pcb) == 0) {
                                break;
                        }


@@ -233,9 +317,7 @@ static void send_fsm(struct tcp_pcb *pcb, struct rfb_state *state) {
        }
        
        if (tcp_output(pcb) != ERR_OK)
        }
        
        if (tcp_output(pcb) != ERR_OK)

-       {

                outputf("RFB: tcp_output bailed in send_fsm?");
                outputf("RFB: tcp_output bailed in send_fsm?");

-       }

 }
 
 static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
 }
 
 static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {


@@ -244,6 +326,16 @@ static err_t rfb_sent(void *arg, struct tcp_pcb *pcb, uint16_t len) {
        return ERR_OK;
 }
 
        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);
 static void close_conn(struct tcp_pcb *pcb, struct rfb_state *state) {
        tcp_arg(pcb, NULL);
        tcp_sent(pcb, NULL);


@@ -353,7 +445,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;


@@ -374,9 +465,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;


@@ -460,7 +553,7 @@ 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... */
+                       /* Kick off a send. */

                        if (state->send_state == SST_IDLE
                            && state->update_requested) {
                                send_fsm(pcb, state);
                        if (state->send_state == SST_IDLE
                            && state->update_requested) {
                                send_fsm(pcb, state);


@@ -512,9 +605,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_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);