/Users/craigcornelius/Projects/SPRING Mac Release 0.2/displayreplicator.cpp

Go to the documentation of this file.

// $Id: displayreplicator.cpp,v 1.61 2006/05/31 00:39:08 craig Exp $
//
// DisplayReplicator code:
//      National Biocomputation Center (http://biocomp.stanford.edu)
//
// Next steps on this code:
//      - doublebuffering
//      - events working correctly
//
// Notes:
//      - by default, we are expecting to be running TCP- it's more reliable and fast enough
//  - we actually implemented a reliable UDP for this, but it greatly increased the code's
//      complexity and provided no real increase in performance
//

#ifdef _WIN32

//#include <windows.h>
#include <winsock.h>

#else

#include <string.h>
#include <unistd.h>
#include <pthread.h>

#endif

#include "displayreplicator.h"

#ifdef _WIN32
#include <glut.h>
#else
#include <GLUT/glut.h>
#include <OpenGL/gl.h>
#endif

//#include <mui.h>
#include <time.h>
#include <sys/timeb.h>
#include <stdlib.h>
#include <stdio.h>
#include "timer.h"
//#include <pthread.h>

#include <iostream>

#include "glui.h"

using namespace std;

const char* DisplayReplicator::rcsid = "@(#) $Id: displayreplicator.cpp,v 1.61 2006/05/31 00:39:08 craig Exp $ $Copyright: (c)2001 National Biocomputation Center, Stanford University $";

#define BLOCKSIZE_X 16
#define BLOCKSIZE_Y     16
#define MAXBLOCKS_X     2048/BLOCKSIZE_X
#define MAXBLOCKS_Y     2048/BLOCKSIZE_Y
#define PERCENT_CHANGE_MAX (-100)
#define RGB_CHANGE_MAX (25)

#define MAX_WIDTH 640
#define MAX_HEIGHT 480
#define MAX_LENGTH_JPEG 100000

char old_data[2][MAXBLOCKS_X][MAXBLOCKS_Y][BLOCKSIZE_X][BLOCKSIZE_Y][3];
bool oldDataInitialized = false;
bool headerInitialized = false;
int do_switchboard = 1;

//static char data[2][MAXBLOCKS_X*MAXBLOCKS_Y*BLOCKSIZE_X*BLOCKSIZE_Y*3];
const char* handshake = "displayserver v3.0";


#ifndef SGI
#ifndef __APPLE__
LPBYTE      OutputBuffer = new unsigned char[MAX_LENGTH_JPEG];     // receive pointer to DIB
DWORD      OutputLength;     // receive length of DIB
BITMAPINFO OutputBitmapInfo;  // receives DIB BITMAPINFO
LPBYTE      OutputBuffer2;     // receive pointer to DIB
DWORD      OutputLength2;     // receive length of DIB
BITMAPINFO OutputBitmapInfo2;  // receives DIB BITMAPINFO
#endif // __APPLE__
#endif // SGI

void DisplayReplicator::InitHeader(int conf_width, int conf_height)
{
#ifndef SGI
#ifndef __APPLE__
    int main_size = conf_width*conf_height*3;
#define PUT_2B(array,offset,value)  \
    (array[offset] = (char) ((value) & 0xFF), \
    array[offset+1] = (char) (((value) >> 8) & 0xFF))
#define PUT_4B(array,offset,value)  \
    (array[offset] = (char) ((value) & 0xFF), \
    array[offset+1] = (char) (((value) >> 8) & 0xFF), \
    array[offset+2] = (char) (((value) >> 16) & 0xFF), \
    array[offset+3] = (char) (((value) >> 24) & 0xFF))
    
    WHeader = (BYTE*)calloc(54+main_size,sizeof(BYTE));
    
    WHeader[0] = 66; // ASCII 'B'
    WHeader[1] = 77; // ASCII 'M'
    PUT_4B(WHeader,2,main_size+54);
    PUT_4B(WHeader,10,54);
    PUT_4B(WHeader,14,40);
    PUT_4B(WHeader,18,conf_width);
    PUT_4B(WHeader,22,conf_height);
    PUT_2B(WHeader,26,1);
    PUT_2B(WHeader,28,24);
    PUT_4B(WHeader,34,main_size);
#endif // __APPLE__
#endif
}

int DisplayReplicator::debug = 0;


DisplayReplicator::DisplayReplicator(int port_in, source_type source_in)
{
    num_socks = 0;
    port = port_in;
    
    mode = unknown;
    source = source_in;
    
    width = height = -1;
    height = MAX_HEIGHT;
    keyfn = NULL; specialfn = NULL; mousefn = NULL; motionfn = NULL;
    
    // allocate memory for largest will need
    block_size = BLOCKSIZE_X * BLOCKSIZE_Y * 3;
    block = new char[block_size];
    buf_size = block_size + 4;
    
    if  (buf_size < MAX_BUF_SIZE)
        g_buf = new char[MAX_BUF_SIZE];
    else
        g_buf = new char[buf_size];
    
    gl_buf = new char[640*480*3];
    
    
    //buf = new char[buf_size];
    buf = g_buf;
    
    // compression
    res_reduction = 1;
    compression = JPEG;
    //compression = color_24bit;
    //compression = color_16bit;
    //compression = color_8bit;
    //compression = greyscale;
    comparison_threshold = (int) (PERCENT_CHANGE_MAX / 100.0f * block_size);
    from_windows = 0;
    
    switch (compression) {
    default:
    case color_24bit:   // 24bits: RGB
        comp_size = BLOCKSIZE_X * BLOCKSIZE_Y * 3;
        break;
    case color_16bit:   // 16 bits: R(6), G(5), B(5)
        comp_size = BLOCKSIZE_X * BLOCKSIZE_Y * 2;
        break;
    case color_8bit:    // 8bits: R(3), G(3), B(2):  rrrgggbb
        comp_size = BLOCKSIZE_X * BLOCKSIZE_Y * 1;
        break;
    case greyscale:     // 8bits: R(3), G(3), B(2):  rrrgggbb
        comp_size = BLOCKSIZE_X * BLOCKSIZE_Y * 1;
        break;
    }  // end switch
    
    buf_size = comp_size + 4;
    if  (buf_size < MAX_BUF_SIZE)
        g_buf = new char[MAX_BUF_SIZE];
    else
        g_buf = new char[buf_size];
    buf = g_buf;
    
    JPEG_data = new char[MAX_WIDTH*MAX_HEIGHT*3];
    
    mySocketBuffer = new char[MAX_BUF_SIZE];
    curBufLen = 0;
    
    memset(old_data, 0, sizeof(old_data));
}

DisplayReplicator::~DisplayReplicator()
{
    for (int i=0; i<num_socks; i++)
        if (sock[i]) delete sock[i];
        mode = unknown;
        width = height = -1;
        keyfn = NULL; specialfn = NULL; mousefn = NULL; motionfn = NULL;
        if (block) { delete block; block = NULL; }
        if (g_buf) { delete buf; buf = NULL; }
        if (mySocketBuffer) { delete mySocketBuffer; mySocketBuffer = NULL; }
}


void DisplayReplicator::setCompression(compression_type comp)
{
    compression = comp;
}

// sends size bytes from buf to other side.  size should always be < buf_size
int DisplayReplicator::send_buf_out_socket(int sock_index, int size, char *whichBuf)
{
    if (whichBuf == NULL)
        whichBuf = buf;
    
    if (debug == 3)
        cerr << "DisplayReplicator::send_buf_out_socket(" << sock_index 
        << ", " << size << ")\n";
    
    // locals- assume doing all (start and end are inclusive)
    int start = 0, end = num_socks-1;
    int ret_val = 0;    // assume everything okay
    
    // if supposed to send to just one, set it up
    if (sock_index != -1) {
        start = sock_index; end = sock_index;
    }
    
    // loop over all the sockets we're supposed to do
    for (int i=start; i<=end; i++) {
        if (!sock[i]) continue;

        int status = sock[i]->BufferedSend(whichBuf, size);

        //int status = sock[i]->Send(whichBuf, size);
        if (!status) {
            cerr << "LOST CONNECTION ON SOCKET " << i << endl;
            Disconnect(i);
            ret_val = -1;
            continue;
        }
    }
    return(ret_val);    // success
}

// user-level function for setting compression parameters
void DisplayReplicator::SetParams(int rr_in, compression_type compression_in,
                                  int comparison_threshold_in, int from_win)
{
    res_reduction = rr_in; 
    compression = compression_in;
    comparison_threshold = comparison_threshold_in;
    
    // encode it
    buf[0] = 3; buf[1] = char(res_reduction); buf[2] = char(compression);
    buf[3] = char(from_win);
    
    // and send to the other side
    send_buf_out_socket(-1, buf_size);
}

// compares the given two blocks
int DisplayReplicator::compare_blocks(char* block1, char* block2)
{
    // if threshold is < 0, don't even bother- assume compare fails
    if ((comparison_threshold < 0) || (!oldDataInitialized)) return(1);
    
    // otherwise, compare
    int s = 0;
    for (int i=0; i<block_size; i++) {
        char c1 = block1[i], c2 = block2[i], cdiff;
        if (c1 > c2) cdiff = c1 - c2;
        else cdiff = c2 - c1;
        if (cdiff >= RGB_CHANGE_MAX) {
            if (comparison_threshold == s) return (1);
            ++s;
        }
    }
    return(0);
}

int DisplayReplicator::encode_block_into_buf(int buf_code, 
                                             int x_loc, int y_loc, int seq_id, char* block)
{
    buf[0] = (char)0xe2;
    if (compression != JPEG) 
    {
        buf[1] = 0x00;
        buf[2] = (unsigned char)(buf_code); 
        buf[3]= (unsigned char)(x_loc); 
        buf[4] = (unsigned char)(y_loc); 
    }
    else 
    {
        buf[1] = 0x01;
        buf[2] = (unsigned char)(buf_code);
        buf[3] = (unsigned char)(from_windows);
        buf[4] = 0x00;
    }
    
    int reduction_factor = 1 << (res_reduction-1);
    
    int x,y;
    int buf_index = 5;  // header info
    switch (compression) {
    default:
    case color_24bit:   // 24bits: RGB
        for ( x=0; x<BLOCKSIZE_X; x += reduction_factor)
            for ( y=0; y<BLOCKSIZE_Y; y += reduction_factor)
            {
                int block_index = x*BLOCKSIZE_Y*3+y*3;
                buf[buf_index++] = (unsigned char)block[block_index++];
                buf[buf_index++] = (unsigned char)block[block_index++];
                buf[buf_index++] = (unsigned char)block[block_index++];
            }
            break;
            
    case color_16bit:   // 16 bits: R(6), G(5), B(5)
        for ( x=0; x<BLOCKSIZE_X; x += reduction_factor)
            for ( y=0; y<BLOCKSIZE_Y; y += reduction_factor)
            {
                int block_index = x*BLOCKSIZE_Y*3+y*3;
                unsigned char r = block[block_index+0];
                unsigned char g = block[block_index+1];
                unsigned char b = block[block_index+2];
                buf[buf_index+0] = (r >> 2) << 2 | (g >> 6);  // rrrrrrgg
                buf[buf_index+1] = ((g&0x3f) >> 3) << 5 | (b >> 3); //gggbbbbb
                buf_index += 2;
            }
            break;
            
    case color_8bit:    // 8bits: R(3), G(3), B(2):  rrrgggbb
        for ( x=0; x<BLOCKSIZE_X; x += reduction_factor)
            for ( y=0; y<BLOCKSIZE_Y; y += reduction_factor)
            {
                int block_index = x*BLOCKSIZE_Y*3+y*3;
                unsigned char r = block[block_index+0];
                unsigned char g = block[block_index+1];
                unsigned char b = block[block_index+2];
                buf[buf_index] = (r & 0xe0) | ((g&0xe0) >> 3) | ((b&0xc0) >> 6);
                buf_index++;
            }
            break;
            
    case greyscale:
        for ( x=0; x<BLOCKSIZE_X; x += reduction_factor)
            for ( y=0; y<BLOCKSIZE_Y; y += reduction_factor)
            {
                int block_index = x*BLOCKSIZE_Y*3+y*3;
                unsigned char r = block[block_index+0];
                unsigned char g = block[block_index+1];
                unsigned char b = block[block_index+2];
                buf[buf_index] = (r + g + b)/3;         // greyscale intensity
                buf_index++;
            }
            break;
    case JPEG: {
#ifndef SGI
#ifndef __APPLE__
        int lBufferSize = width*height*3;
        if (!headerInitialized)
        {
            InitHeader(width, height);
            headerInitialized = true;
        }
        memcpy(WHeader + 54,block,lBufferSize);

#ifdef _WIN32           
        CompressToJPEG(WHeader,lBufferSize + 54,&OutputBuffer,&OutputLength);
#endif

        memcpy(buf+5, OutputBuffer, OutputLength);
        return (OutputLength+5);
#endif // __APPLE__
#endif
               }
    }  // end switch
    // and return the number of bytes encoded
    return(buf_index);
}

void DisplayReplicator::decode_block_from_buf(int* buf_code_p, 
                                              int* x_p, int* y_p, int* seq_id_p, char* block, int JPEG_size)
{
    *buf_code_p = int((unsigned char)buf[2]);
    *x_p = int((unsigned char)buf[3]);
    *y_p = int((unsigned char)buf[4]);
    *seq_id_p = 1;
    int x,y;
    
    int reduction_factor = 1 << (res_reduction-1);
    
    if (reduction_factor == 1)
    {
        
        char *ptBuf = buf + 4;
        char *ptBlock = block;
        
        switch (compression) {
        default:
        case color_24bit:       // 24bits: RGB
            memcpy(block, buf + 4, block_size);
            break;
        case color_16bit:       // 16 bits: R(6), G(5), B(5)
            for ( x=0; x<BLOCKSIZE_X; ++x) {
                for ( y=0; y<BLOCKSIZE_Y; ++y) {
                    *(ptBlock++) = *ptBuf & 0xfc;
                    *ptBlock = *ptBuf << 6;
                    *(ptBlock++) |= (*(++ptBuf) & 0xe0) >> 2;
                    *(ptBlock++) = *(ptBuf++) << 3;
                } // end for y
            }// end for x
            break;
        case color_8bit:        // 8bits: R(3), G(3), B(2): rrrgggbb
            for ( x=0; x<BLOCKSIZE_X; ++x) {
                for ( y=0; y<BLOCKSIZE_Y; ++y) {
                    *(ptBlock++) = *ptBuf & 0xe0;
                    *(ptBlock++) = (*ptBuf & 0x1c) << 3;
                    *(ptBlock++) = (*(ptBuf++) & 0x03) << 6;
                }// end for y
            }// end for x
            break;
        case greyscale: // 8bits: R(3), G(3), B(2): rrrgggbb
            for ( x=0; x<BLOCKSIZE_X; ++x) {
                for ( y=0; y<BLOCKSIZE_Y; ++y) {
                    *(ptBlock++) = *ptBuf; // greyscale intensity
                    *(ptBlock++) = *ptBuf; // greyscale intensity
                    *(ptBlock++) = *(ptBuf++); // greyscale intensity
                }// end for y
            }// end for x
            break;
        case JPEG: {
#ifndef SGI
#ifndef __APPLE__
#ifdef WIN_32
            ExpandJPEGTo24BitDIB((BYTE*)ptBuf,JPEG_size,&OutputBuffer2,&OutputLength2);
#endif

            memcpy(ptBlock,OutputBuffer2, OutputLength2);
            delete OutputBuffer2;
#endif // __APPLE__
#endif
            break;
                   }
        }  // end switch
    }
    else
    {
        cerr << "Oups\n";
        int buf_index = 4;
        for ( x=0; x<BLOCKSIZE_X; x += reduction_factor) {
            for ( y=0; y<BLOCKSIZE_Y; y += reduction_factor) {
                int block_index = x*BLOCKSIZE_Y*3+y*3;
                unsigned char r,g,b;
                switch (compression) {
                default:
                case color_24bit:       // 24bits: RGB
                    r = buf[buf_index+0];
                    g = buf[buf_index+1];
                    b = buf[buf_index+2];
                    buf_index += 3;
                    break;
                case color_16bit:       // 16 bits: R(6), G(5), B(5)
                    r = buf[buf_index] & 0xfc;
                    g = (buf[buf_index] << 6) | ((buf[buf_index+1]&0xe0) >> 2);
                    b = (buf[buf_index+1] << 3);
                    buf_index += 2;
                    break;
                case color_8bit:        // 8bits: R(3), G(3), B(2): rrrgggbb
                    r = buf[buf_index] & 0xe0;
                    g = (buf[buf_index] & 0x1c) << 3;
                    b = (buf[buf_index] & 0x03) << 6;
                    buf_index++;
                    break;
                case greyscale: // 8bits: R(3), G(3), B(2): rrrgggbb
                    r = g = b = buf[buf_index]; // greyscale intensity
                    buf_index++;
                    break;
                }  // end switch
                
                
                // set values
                for (int xx=0; xx<reduction_factor; xx++) {
                    for (int yy=0; yy<reduction_factor; yy++) {
                        int subblock_index = block_index + xx*BLOCKSIZE_Y*3 +yy*3;
                        block[subblock_index + 0] = r;
                        block[subblock_index + 1] = g;
                        block[subblock_index + 2] = b;
                    } // for yy
                } // for xx
            } // for y
        } // for x
    } // End reduction==1
}

// block_index is the index of the block in the processed blocks list or -1
int DisplayReplicator::SendBlock(int buf_code, int x, int y,
                                 char* block, int which_socket, int is_a_resend, bool flushBuffer)
{
        int len;

    // if flushBuffer==true with block==NULL, then flush buffer and exit
    if ((flushBuffer) && (block == NULL))
    {
        if (debug) cerr << "Flush Required with Block = NULL and curBufLen = " << curBufLen << "\n";
        if (curBufLen > 0)
            send_buf_out_socket(which_socket, curBufLen, (char *)mySocketBuffer);
        curBufLen = 0;
        return -1;
    }
    
    // keep track of it in our set
    int seq_id = -1;
    
    
    // encode info of block into buf
    len = encode_block_into_buf(buf_code, x, y, seq_id, (char*)block);
    
    if ((len > buf_size) && (debug))
        cerr << "Warning : size of encoded block (=" << len 
        << ") > size of buffer (=" << buf_size << ")\n";
    
    // debugging
    if (debug == 3) 
        cerr << "Sending block " << int(buf_code) << ", " << x << ", " << y << endl;
    
    // Place the block in Buffer and flush if needed / required
    
    // Flush Is required
    if(flushBuffer)
    {
        if (debug) cerr << "Flush Required ";
        // If appending block to buffer cause buffer-overflow, send buffer now
        // and then take care of block (that is reset curBufLen to 0)
        if ((curBufLen + len >= MAX_BUF_SIZE) && (curBufLen > 0))
        {
            if (debug) cerr << "causing BufferOverflow ";
            send_buf_out_socket(which_socket, curBufLen, (char *)mySocketBuffer);
            curBufLen = 0;
        }
        
        if (debug) cerr << "with curBufLen = " << curBufLen << " and len = " << len << "\n";
        // For performance purposes ... if buffer is currently empty, send block normally
        // (avoid memcpy of 'else' case)
        if (curBufLen == 0)
            send_buf_out_socket(which_socket, len, NULL);
        
        else // Append new block and sends everything, resetting buffer as well
        {
            memcpy(&mySocketBuffer[curBufLen], buf, len);
            send_buf_out_socket(which_socket, curBufLen + len, (char *)mySocketBuffer);
            curBufLen = 0;
        }
    }
    
    else // Flush was not required
    {
        // If len > MAX_BUF_SIZE, no buffering is possible... Immediate flushing is required
        if (len > MAX_BUF_SIZE)
        {
            if (debug) cerr << "Flush Forced with MAX_BUF_SIZE < len (=" << len << ")\n";
            send_buf_out_socket(which_socket, len, NULL);       
        }
        // If buffer overflow, force flush and then append block to buffer
        else if (curBufLen + len >= MAX_BUF_SIZE)
        {
            if (debug) cerr << "Flush Forced with BufferOverflow, curBufLen = " << curBufLen << "\n";
            send_buf_out_socket(which_socket, curBufLen, (char *)mySocketBuffer);
            memcpy(&mySocketBuffer[0], buf, len);
            curBufLen = len;
        }
        else //otherwise just append block to buffer
        {
            memcpy(&mySocketBuffer[curBufLen], buf, len);
            curBufLen += len;
        }
    }
    
    // return length of message for performance stats
    return(len);
}

void DisplayReplicator::PaintBlock(int which_buffer, char xloc, char yloc, 
                                   char* block,bool paintAll)
{
    if (!paintAll)
    {
        glDrawBuffer(which_buffer);     
        glRasterPos2i(xloc * BLOCKSIZE_X, yloc * BLOCKSIZE_Y);
        glDrawPixels(BLOCKSIZE_X, BLOCKSIZE_Y, GL_RGB, GL_UNSIGNED_BYTE, block);
    }
    else
    {
        glDrawBuffer(which_buffer);     
        glRasterPos2i(xloc * BLOCKSIZE_X, yloc * BLOCKSIZE_Y);
        if (!from_windows)
            glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, block);
        else {
#ifdef _WIN32
            glDrawPixels(width, height, GL_BGR_EXT, GL_UNSIGNED_BYTE, block);
#else
            glDrawPixels(width, height, GL_BGR, GL_UNSIGNED_BYTE, block);
#endif
        }
    }
}

void DisplayReplicator::Reshape(int w, int h)
{ width = w; height = h; 
#ifndef SGI
#ifndef __APPLE__
delete WHeader; 
InitHeader(w,h);
headerInitialized = true;
#endif // __APPLE__
#endif
}

void DisplayReplicator::SendKeyEvent(char key, int x, int y)
{
    if (debug) cerr << "Sending key " << key << " @ " << x << ", " << y << endl;
    sprintf(buf, "%c %d %d %d", 'k', key, x, y);
    send_buf_out_socket(0, buf_size);
}

void DisplayReplicator::SendSpecialKeyEvent(int key, int x, int y)
{
    if (debug) cerr << "Sending special key " << key << " @ " << x << ", " 
        << y << endl;
    sprintf(buf, "%c %d %d %d", 's', key, x, y);
    send_buf_out_socket(0, buf_size);
}

void DisplayReplicator::SendMouseEvent(int button, int state, int x, int y)
{
    if (debug) cerr << "Sending mouse " << button << "," << state << " @ " 
        << x << ", " << y << endl;
    sprintf(buf, "%c %d %d %d %d", 'b', button, state, x, y);
    send_buf_out_socket(0, buf_size);
}

void DisplayReplicator::SendMotionEvent(int x, int y)
{
    if (debug) cerr << "Sending motion @ " << x << ", " << y << endl;
    sprintf(buf, "%c %d %d", 'm', x, y);
    send_buf_out_socket(0, buf_size);
}

void DisplayReplicator::RegisterEventHandlers(
                                              void(*keyfn_in)(unsigned char,int,int),
                                              void(*specialfn_in)(int,int,int),
                                              void(*mousefn_in)(int,int,int,int),
                                              void(*motionfn_in)(int,int) )
{
    keyfn = keyfn_in;
    specialfn = specialfn_in;
    mousefn = mousefn_in;
    motionfn = motionfn_in;
}

void DisplayReplicator::SendScreenRefresh(int which_socket)
{
    if (debug == 3) 
        cerr << "SendScreenRefresh()\n";
    
    if (num_socks == 0) return;
    
    // encode it
    buf[0] = 0;
    
    // send the block out
    send_buf_out_socket(which_socket, buf_size);
}

// sends the whole screen to display[i]
void DisplayReplicator::SendWholeScreen(int which_buffer, int sock_index)
{
    if (debug == 3) 
        cerr << "SendWholeScreen(" << which_buffer << ", " << sock_index 
        << ")\n";
    
    if (num_socks == 0) return;
    
    glReadBuffer(which_buffer); 
    
    int num_blocks_x = width/BLOCKSIZE_X;
    int num_blocks_y = height/BLOCKSIZE_Y;
    for (int x=0; x<num_blocks_x; x++) {
        for (int y=0; y<num_blocks_y; y++) {
            int xloc = x * BLOCKSIZE_X, yloc = y * BLOCKSIZE_Y;
            glReadPixels(xloc,yloc, BLOCKSIZE_X,BLOCKSIZE_Y, GL_RGB, 
                GL_UNSIGNED_BYTE, &block);
            
            // encode the buffer and location of the block
            int buf_code = 1;
            if (which_buffer == GL_FRONT_RIGHT) buf_code = 2;
            
            // send to other side
            SendBlock(buf_code, x, y, block, sock_index);
        }
    }
    
    // and tell them to update
    SendScreenRefresh(sock_index);
}

void DisplayReplicator::SendScreenUpdates(int which_buffer, void* data_in)
{
    if (debug == 3) cerr << "SendScreenUpdates(" << which_buffer << ")\n";
    
    if (num_socks == 0)
    {   //cerr <<  "No socket in SendScreenUpdate\n";
        return; }
    //else
    //cerr << "Good, we have " << num_socks << " connections in SendScreenUpdate\n";
    
    
    // get the data into local memory (from user memory or screen)
    //char *data = new char[width * height * 3];
    // for now, do static allocation, otherwise JPEG crashes
    
        // !!! Dangerous to limit the size!
        static char data[1024 * 1024 * 3];      
    
    switch (source) {
    case source_memory:
        memcpy(data, data_in, width*height*3);
        break;
    case source_screen: // read the screen at that location into data
        //cerr << "doing read from buffer " << int(which_buffer) 
        //<< "with width=" << width << " and height=" << height
        //<< " into " << int(data) << endl;
        glReadBuffer(which_buffer);     
                // NOTE: Please use GL_BGR not GL_RGB for compatibility with windows DIB.
        // Note: ReadPixels is fast (can go video speed)
#ifdef _WIN32
        glReadPixels(0,0, width,height, GL_BGR_EXT, GL_UNSIGNED_BYTE, &data);
#else
        glReadPixels(0,0, width,height, GL_BGR, GL_UNSIGNED_BYTE, &data);
#endif
        break;
    }  // end switch
    
    // get a code for the buffer
    int buf_code = 1;   // left
    if (which_buffer == GL_FRONT_RIGHT) buf_code = 2;  // right
    
    // big loop to look over and send blocks
    Timer timer;
    int blocks_sent1 = 0, blocks_sent2 = 0, bytes_sent = 0;
    if (compression != JPEG) // Backward compatibility
    {
        int num_blocks_x = width/BLOCKSIZE_X;
        int num_blocks_y = height/BLOCKSIZE_Y;
        for (int x=0; x<num_blocks_x; x++) {
            for (int y=0; y<num_blocks_y; y++) {
                // get the block number of where we are
                int xloc = x * BLOCKSIZE_X, yloc = y * BLOCKSIZE_Y;
                
                { // copy over the data from the buffer into the block
                    for (int yy=0; yy<BLOCKSIZE_Y; yy++) {
                        memcpy(&(block[yy*BLOCKSIZE_X*3]), 
                            &(data[(yloc+yy)*width*3+xloc*3]), BLOCKSIZE_X*3);
                    }
                }
                
                // compare them against our old buffer
                int diff = compare_blocks(block, (char*)old_data[buf_code-1][x][y]);
                
                // if diff, send `em
                
                if (diff) {
                    
                    // send to other side but do not flush each time.... buffers instead
                    int len = SendBlock(buf_code, x, y, block, -1, 0, false);
                    /*       static int nbBlocks;
                    nbBlocks++;
                    if (!(nbBlocks%1000000))
                    cerr << "NbBlocks : " << nbBlocks / 1000000 << " Million\n"; */
                    // update the old data buffer
                    memcpy(old_data[buf_code-1][x][y], block, block_size);
                    
                    // keep stats
                    if (buf_code == 1)
                        blocks_sent1++;
                    else
                        blocks_sent2++;
                    //blocks_sent++;
                    bytes_sent += len * num_socks;
                }
            }
        }
        //cerr << "Block Sent1 : " << blocks_sent1 << " Block Sent2 : " << blocks_sent2 << " buffCode = "  << buf_code << "\n";
        // Flush buffer at the end
        SendBlock(0, 0, 0, NULL, -1, 0, true);
        
        // and tell them all to update
        //SendScreenRefresh(-1);
        
        
        oldDataInitialized = true;
    }
    else // We are doing JPEG compression
    {
        int len = SendBlock(buf_code,0,0,data,-1,0,true);
        bytes_sent += len;
    }
    
    if (debug == 1) {
        int bps = int(bytes_sent/timer.GetElapsedTime());
        //      cerr << blocks_sent << " blocks sent times " << num_socks << " clients: ";
        cerr << bps * 8/1024 << " Kbits/second,relative\n";
        cerr << "    seeing " << 1.0/global_timer.GetElapsedTime() 
            << " updates per second, absolute\n";
        global_timer.Reset();
    }
}

void DisplayReplicator::ReceiveScreenUpdate(int which_buffer, char* data, int JPEG_size)
{
    int buf_code, x, y, seq_id;
    
    // decode it
    if (compression != JPEG)
        decode_block_from_buf(&buf_code, &x, &y, &seq_id, block,JPEG_size);
    else
        decode_block_from_buf(&buf_code, &x, &y, &seq_id, JPEG_data,JPEG_size);
    
    
    // and write it (to memory or to the screen)
    switch (source) {
    case source_screen:
        if (compression != JPEG)
            PaintBlock(which_buffer, x, y, block);
        else
            PaintBlock(which_buffer, x, y, JPEG_data, true);
        break;
    case source_memory:
        if (!data) break;
        // get the pixel location of where we are
        int xloc = x * BLOCKSIZE_X, yloc = y * BLOCKSIZE_Y;
        
        // copy over the data from the block into the buffer
        for (int yy=0; yy<BLOCKSIZE_Y; yy++) {
            memcpy(&(data[(yloc+yy)*width*3+xloc*3]),
                &(block[yy*BLOCKSIZE_X*3]), BLOCKSIZE_X*3);
        }
        break;
    }  // end switch
    
}


void DisplayReplicator::Connect(char* server, bool switchboard, char channel, char* optBuffer, bool blocking)
{
    // make one
    cerr << "connecting to " << server << "on port " << port << "..." << endl;
    int cur_sock = num_socks++;
    
    // create the socket
    sock[cur_sock] = new Socket(server,Socket::tcp,port);
    if (!sock[cur_sock]) { num_socks--; return; }
    
    do
    {
        int status;
        if (!switchboard) {
            // after a connection is made, send handshake data
            strcpy(buf, handshake);
            //  status = send_buf_out_socket(cur_sock, buf_size);
            cerr << "sent handshake of [" << buf << "]\n";
        }
        else {
            char system_info[80]; 
#ifdef _WIN32
            sprintf(system_info, "WIN32 PC");
#elif linux
            sprintf(system_info, "Linux PC");
#else
            sprintf(system_info,"Unix Machine");
#endif
            cerr << "channel " << int(channel) << "\n";
            char InitBuf[256];
            // make string for given channel and say who we are
            if (channel != -1)
                sprintf(InitBuf, "%c%c%s", (char)CHANNEL_REQUEST_CODE, (char)channel, system_info);
            else
                sprintf(InitBuf, "%c%s", (char)SYSTEM_INFO_CODE, system_info);
            
            if (optBuffer != NULL) strcat(InitBuf, optBuffer);
            cerr << "Switchboard initbuf = [" << InitBuf << "]\n";
            memcpy(buf,InitBuf,256);
            status = send_buf_out_socket(cur_sock, buf_size);
            
        }
        
//#define DO_HANDSHAKE
#ifdef DO_HANDSHAKE
        // test their response
        sock[cur_sock]->BufferedReceive(buf,buf_size);
        cout << "RESP: [" << buf << "]\n";
        if (strncmp(buf,"ACK", 3) == 0) {
            
            if (debug)
                cerr << "Received Confirmation of ACK\n";
            
            // setup to do the session
#else
            if (1) {
                if (debug)
                    cerr << "Not doing handshake- assumed okay\n";
                
#endif
                blocking = false;
                // send the whole screen to bring them up to speed
                //              SendWholeScreen(GL_FRONT_LEFT, cur_sock);
                //              SendWholeScreen(GL_FRONT_RIGHT, cur_sock);
                
            } else {
                // end the session
                cerr << "Connection rejected!  (buf = [" << buf << "])\n";
                // If blocking try again, and again....
                if (!blocking)
                {
                    Disconnect(cur_sock);
                    return;
                }
            }
        } while (blocking);
        
        // set our mode of operation
        mode = sender;
        
        // send them our current compression parameters
        //SetParams(res_reduction, compression, comparison_threshold,from_windows);
    }
    
    void DisplayReplicator::Disconnect(int connection_to_kill)
    {
        if (debug) cerr << "Disconnect(" << connection_to_kill << ")\n";
        if (connection_to_kill >= num_socks) return;
        delete sock[connection_to_kill];
        for (int i=connection_to_kill; i<num_socks-1; i++)
            sock[i] = sock[i+1];
        num_socks--;
    }
    
    
    void DisplayReplicator::Listen()
    {
        // wait for message from network to start
        cerr << "Waiting for communication...";
        int cur_sock = num_socks;
        
        // make new socket
        sock[cur_sock] = new Socket(NULL,Socket::tcp,port+cur_sock);
        if (!sock[cur_sock]) return;
        
        // otherwise, we've got one
        cerr << "\n\n\n" << num_socks++ << "\n\n\n\n";
        cerr << endl;
        
#ifdef DO_HANDSHAKE
        // after a connection is made, get handshake data
        cerr << "received connection" << endl;
        //char* ackbuf = new char[buf_size];
        sock[cur_sock]->BufferedReceive(buf,buf_size);
        
        // debugging
        cout << "Got handshake of [" << buf << "]\n";
        
        // test their hello
        if (strncmp(buf,handshake, strlen(handshake)) == 0) {
            // if handshake successful send ACK and start a session
            sprintf(buf, "ACK");
            send_buf_out_socket(cur_sock, buf_size);
            cerr << "handshake okay- Connection established.\n";
        } else {
            // else send NAK
            cerr << "NAK\n";
            sprintf(buf, "NAK");
            send_buf_out_socket(cur_sock, buf_size);
            
            // end the session
            Disconnect(cur_sock);
        }
        //delete ack_buf;
#endif
        
        // set our mode of operation
        mode = receiver;
    }
    
    // sender should use nonblocking to just see if anything's there
    // receiver (displayserver) should block so it can detect a broken connection
    void DisplayReplicator::Update(int nonblocking)
    {
        if (debug == 4) cerr << "Update(" << nonblocking << ")\n";
        
        // shortcut
        if (num_socks == 0) return;
        
        //int nbBlocks = (int) ((float)width / BLOCKSIZE_X * height / BLOCKSIZE_Y); // keep metrics
        int num_messages = 0, num_bytes = 0;
        Timer timer;
        
        do {
            // if they have anything they've sent us, fake it as if it were local
            for (int i=0; i<num_socks; i++) {
                
                if (debug == 4)
                    cerr << "Queue on socket " << i << " is "
                    << sock[i]->InputQueueSize() << endl;
                
                
                int g_count = 0;
                
                //int maxBlocks = width / BLOCKSIZE_X * height / BLOCKSIZE_Y;
                int curLen = 0;
                g_count++;
                if (!(g_count%100)) cerr << "g_count = " << g_count << "\n";
                
                if (debug == 5)
                    cerr << "Incoming! - command=" << int(buf[0]) << endl;
                
                // get the message
                int status = 1;
                
                // receive the message
                //status = sock[i]->BufferedReceive(g_buf, MAX_BUF_SIZE, !nonblocking);
                status = sock[i]->BufferedReceive(g_buf, MAX_BUF_SIZE);
                buf = g_buf;
                
                
                if (!status) {
                    if (debug) cerr << "2:LOST CONNECTION ON SOCKET " << i << endl;
                    Disconnect(i);
                    continue;
                }
                
                if (debug)
                    cerr << "status " << status << " comp " << comp_size + 4 << "\n";
                
                while (curLen*buf_size  < status)
                {   
                    
                    if (debug) {
                        cerr << " curLen " << curLen;
                        cerr << " buf[0] " << (int)buf[0];
                        cerr << " buf[1] " << (int)buf[1];
                        cerr << " buf[2] " << (int)buf[2];
                        cerr << " buf[3] " << (int)buf[3] << "\n";
                    }
                    
                    // based on operation code, do stuff
                    switch (buf[0]) {
                    case 0:
                        //glClear(GL_COLOR_BUFFER_BIT);
                        glutPostRedisplay();
                        break;
                    case 1: ReceiveScreenUpdate(GL_FRONT_LEFT, buf, status);
                        //cerr << "     Left Buffer \n";
                        break;
                    case 2: ReceiveScreenUpdate(GL_FRONT_RIGHT, buf, status);
                        //cerr << "Right Buffer \n";
                        break;
                    case 3: {
                        res_reduction = int(buf[1]);
                        compression = compression_type(buf[2]);
                        from_windows = int(buf[3]);
                        cerr << "received res_reduce = " << int(buf[1])
                            << ", compression = " << int(buf[2]) << endl;
                        break;
                            }
                    case 'q': Disconnect(i); break;
                    case 'k': {
                        int x, y, dummykey;
                        sscanf(buf, "%*c %d %d %d", &dummykey, &x, &y);
                        char key = char(dummykey);
                        if (debug) cerr << "Got key [" << key << "] at "
                            << x << ", " << y << endl;
                        if (keyfn) (*keyfn)(key,x,y);
                        break;
                              }
                    case 's': {
                        int key; int x, y;
                        sscanf(buf, "%*c %d %d %d", &key, &x, &y);
                        if (debug) cerr << "Got special key [" << key << "] at "
                            << x << ", " << y << endl;
                        if (specialfn) (*specialfn)(key,x,y);
                        break;
                              }
                    case 'b': {
                        int button, state, x, y;
                        sscanf(buf, "%*c %d %d %d %d", &button, &state, &x, &y);
                        if (debug) cerr << "Got mouse " << button << "," << state
                            << " at " << x << ", " << y << endl;
                        if (mousefn) (*mousefn)(button,state,x,y);
                        break;
                              }
                    case 'm': {
                        int x, y;
                        sscanf(buf, "%*c %d %d", &x, &y);
                        if (debug) cerr << "Got motion at " << x << ", " << y << endl;
                        if (motionfn) (*motionfn)(x,y);
                        break;
                              }
                    default: break;     // unknown
                        
                    }  // end switch
                    ++curLen;
                    buf += comp_size + 4 ;
                   
                    if (compression == JPEG) curLen = status; // make sure we get out of the inner while
                }
                
                buf = g_buf;
                
                // keep metrics
                num_messages++;
                num_bytes += status;
                //if (buf[0] == 0) break;
                //if (sock[i]->InputQueueSize() <= 0) g_count = 0;
}  // end for
      } while(1); //sock[i]->InputQueueSize() > 0);
      
      
      // debugging
      if (debug == 2) {
          int bps = int(num_bytes/timer.GetElapsedTime());
          cerr << num_messages << " messages received from " << num_socks
              << " servers: ";
          cerr << bps * 8/1024 << " Kbits/second,relative\n";
          cerr << "seeing " << 1.0/global_timer.GetElapsedTime()
              << " updates per second, absolute\n";
          global_timer.Reset();
      }
}

GLUI_StaticText* ac = NULL;
char new_machine_name[300];
int new_proto = 0;
void DisplayReplicator::Connect_CB(int dr_p_in)
{
    DisplayReplicator* dr_p = (DisplayReplicator*)dr_p_in;
    
    // and do the connect
    dr_p->Connect(new_machine_name,do_switchboard,-1,": Spring code");
    
    // update the num connections table
    char buf[80];
    sprintf(buf, "Num Active Connections = %d", dr_p->NumConnections());
    if (ac) ac->set_text(buf);
}

int new_rr = 1;
int new_ct = 0;
int new_compare = 0;
void DisplayReplicator::Params_CB(int dr_p_in)
{
    DisplayReplicator* dr_p = (DisplayReplicator*)dr_p_in;
    dr_p->SetParams(new_rr, DisplayReplicator::compression_type(new_ct),
        new_compare);
}


void DisplayReplicator::Menu()
{
    extern int main_window_id;
    extern void Close(int);
    
    GLUI *glui = GLUI_Master.create_glui((const char*)"Display Replicator", 0, -1, -1);
    { GLUI_Panel* p = glui->add_panel("Current info");
    p->set_alignment(GLUI_ALIGN_LEFT);
    
    char buf[80];
    sprintf(buf, "Num Active Connections = %d", NumConnections());
    ac = glui->add_statictext_to_panel(p, buf);
    
    // read in other values from current settings
    GetParams(&new_rr, (compression_type*)&new_ct, &new_compare);
    
    // make the compression panel
    GLUI_Spinner* s0 = glui->add_spinner_to_panel(p, "Resolution Reduction",
        GLUI_SPINNER_INT, &new_rr);
    s0->set_int_limits(1,6);
    GLUI_Listbox* lb0 = glui->add_listbox_to_panel(p, "Compression Type",
        &new_ct);
    lb0->add_item((int)DisplayReplicator::JPEG, (const char*)"JPEG");
    lb0->add_item((int)DisplayReplicator::color_24bit, (const char*)"24bit Color");
    lb0->add_item((int)DisplayReplicator::color_16bit, (const char*)"16bit Color");
    lb0->add_item((int)DisplayReplicator::color_8bit, (const char*)"8bit Color");
    lb0->add_item((int)DisplayReplicator::greyscale, (const char*)"Greyscale");
    GLUI_Spinner* s1 = glui->add_spinner_to_panel(p, (const char*)"Comparison Threshold",
        GLUI_SPINNER_INT, &new_compare);
    s1->set_int_limits(-1,1000);
    
    glui->add_button_to_panel(p, "Apply", (int)this,
        (GLUI_Update_CB)Params_CB);
    }
    
    { GLUI_Panel* p = glui->add_panel("");
    GLUI_EditText* et1 = glui->add_edittext_to_panel(p, "Connect to:",
        GLUI_EDITTEXT_TEXT, new_machine_name);
    
    et1->set_text("biocomp.stanford.edu");
    
    et1->set_w(300); et1->set_h(20);
    
    GLUI_Checkbox* cb1 = glui->add_checkbox_to_panel(p,"Use Switchboard", &do_switchboard);
    glui->add_button_to_panel(p, "Connect", (int)this,
        (GLUI_Update_CB)Connect_CB);
    }
    
    glui->add_separator();
    { GLUI_Panel* pe = glui->add_panel("");
    glui->add_button_to_panel(pe, "Close", (int)glui,
        (GLUI_Update_CB)Close);
    }
    glui->set_main_gfx_window(main_window_id);
}

---