rfbproto.c

Microwindows genesis was with the NanoGUI project, and is now the primary distribution for both th

	    switch (rect.encoding) {

	    case rfbEncodingRaw:

		bytesPerLine = rect.r.w * myFormat.bitsPerPixel / 8;
		linesToRead = BUFFER_SIZE / bytesPerLine;

		while (rect.r.h > 0) {
		    if (linesToRead > rect.r.h)
			linesToRead = rect.r.h;

		    if (!ReadExact(rfbsock, buffer,bytesPerLine * linesToRead))
			return False;

		    CopyDataToScreen((CARD8 *)buffer, rect.r.x, rect.r.y,
				     rect.r.w, linesToRead);

		    rect.r.h -= linesToRead;
		    rect.r.y += linesToRead;

		}
		break;

	    case rfbEncodingCopyRect:
	    {
		rfbCopyRect cr;

		if (!ReadExact(rfbsock, (char *)&cr, sz_rfbCopyRect))
		    return False;

		cr.srcX = Swap16IfLE(cr.srcX);
		cr.srcY = Swap16IfLE(cr.srcY);

		if (copyRectDelay != 0) {
		    XFillRectangle(dpy, canvas, srcGC, cr.srcX, cr.srcY,
				   rect.r.w, rect.r.h);
		    XFillRectangle(dpy, canvas, dstGC, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);
		    XSync(dpy,False);
		    usleep(copyRectDelay * 1000);
		    XFillRectangle(dpy, canvas, dstGC, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);
		    XFillRectangle(dpy, canvas, srcGC, cr.srcX, cr.srcY,
				   rect.r.w, rect.r.h);
		}

		XCopyArea(dpy, canvas, canvas, gc, cr.srcX, cr.srcY,
			  rect.r.w, rect.r.h, rect.r.x, rect.r.y);

		break;
	    }

	    case rfbEncodingRRE:
	    {
		rfbRREHeader hdr;
		CARD8 pix8;
		CARD16 pix16;
		CARD32 pix32;
		XGCValues gcv;
		rfbRectangle subrect;
		int j;

		if (!ReadExact(rfbsock, (char *)&hdr, sz_rfbRREHeader))
		    return False;

		hdr.nSubrects = Swap32IfLE(hdr.nSubrects);

		switch (myFormat.bitsPerPixel) {

		case 8:
		    if (!ReadExact(rfbsock, (char *)&pix8, 1))
			return False;

		    gcv.foreground = (useBGR233 ? BGR233ToPixel[pix8]
				      : pix8);
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    for (j = 0; j < hdr.nSubrects; j++) {
			if (!ReadExact(rfbsock, (char *)&pix8, 1))
			    return False;

			if (!ReadExact(rfbsock, (char *)&subrect,
					 sz_rfbRectangle))
			    return False;

			subrect.x = Swap16IfLE(subrect.x);
			subrect.y = Swap16IfLE(subrect.y);
			subrect.w = Swap16IfLE(subrect.w);
			subrect.h = Swap16IfLE(subrect.h);

			gcv.foreground = (useBGR233 ? BGR233ToPixel[pix8]
					  : pix8);
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + subrect.x,
				       rect.r.y + subrect.y, subrect.w,
				       subrect.h);
		    }
		    break;

		case 16:
		    if (!ReadExact(rfbsock, (char *)&pix16, 2))
			return False;

		    gcv.foreground = pix16;
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    for (j = 0; j < hdr.nSubrects; j++) {
			if (!ReadExact(rfbsock, (char *)&pix16, 2))
			    return False;

			if (!ReadExact(rfbsock, (char *)&subrect,
					 sz_rfbRectangle))
			    return False;

			subrect.x = Swap16IfLE(subrect.x);
			subrect.y = Swap16IfLE(subrect.y);
			subrect.w = Swap16IfLE(subrect.w);
			subrect.h = Swap16IfLE(subrect.h);

			gcv.foreground = pix16;
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + subrect.x,
				       rect.r.y + subrect.y, subrect.w,
				       subrect.h);
		    }
		    break;

		case 32:
		    if (!ReadExact(rfbsock, (char *)&pix32, 4))
			return False;

		    gcv.foreground = pix32;
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    for (j = 0; j < hdr.nSubrects; j++) {
			if (!ReadExact(rfbsock, (char *)&pix32, 4))
			    return False;

			if (!ReadExact(rfbsock, (char *)&subrect,
					 sz_rfbRectangle))
			    return False;

			subrect.x = Swap16IfLE(subrect.x);
			subrect.y = Swap16IfLE(subrect.y);
			subrect.w = Swap16IfLE(subrect.w);
			subrect.h = Swap16IfLE(subrect.h);

			gcv.foreground = pix32;
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + subrect.x,
				       rect.r.y + subrect.y, subrect.w,
				       subrect.h);
		    }
		    break;
		}
		break;
	    }

	    case rfbEncodingCoRRE:
	    {
		rfbRREHeader hdr;
		CARD8 pix8;
		CARD16 pix16;
		CARD32 pix32;
		XGCValues gcv;
		int j;
		CARD8 *ptr;
		register int x, y, w, h;

		if (!ReadExact(rfbsock, (char *)&hdr, sz_rfbRREHeader))
		    return False;

		hdr.nSubrects = Swap32IfLE(hdr.nSubrects);

		switch (myFormat.bitsPerPixel) {

		case 8:
		    if (!ReadExact(rfbsock, (char *)&pix8, 1))
			return False;

		    gcv.foreground = (useBGR233 ? BGR233ToPixel[pix8]
				      : pix8);
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    if (!ReadExact(rfbsock, buffer, hdr.nSubrects * 5))
			return False;

		    ptr = (CARD8 *)buffer;

		    for (j = 0; j < hdr.nSubrects; j++) {
			pix8 = *ptr++;
			x = *ptr++;
			y = *ptr++;
			w = *ptr++;
			h = *ptr++;
			gcv.foreground = (useBGR233 ? BGR233ToPixel[pix8]
					  : pix8);
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + x,
				       rect.r.y + y, w, h);
		    }
		    break;

		case 16:
		    if (!ReadExact(rfbsock, (char *)&pix16, 2))
			return False;

		    gcv.foreground = pix16;
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    if (!ReadExact(rfbsock, buffer, hdr.nSubrects * 6))
			return False;

		    ptr = (CARD8 *)buffer;

		    for (j = 0; j < hdr.nSubrects; j++) {
			pix16 = *(CARD16 *)ptr;
			ptr += 2;
			x = *ptr++;
			y = *ptr++;
			w = *ptr++;
			h = *ptr++;
			gcv.foreground = pix16;
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + x,
				       rect.r.y + y, w, h);
		    }
		    break;

		case 32:
		    if (!ReadExact(rfbsock, (char *)&pix32, 4))
			return False;

		    gcv.foreground = pix32;
		    XChangeGC(dpy, gc, GCForeground, &gcv);
		    XFillRectangle(dpy, canvas, gc, rect.r.x, rect.r.y,
				   rect.r.w, rect.r.h);

		    if (!ReadExact(rfbsock, buffer, hdr.nSubrects * 8))
			return False;

		    ptr = (CARD8 *)buffer;

		    for (j = 0; j < hdr.nSubrects; j++) {
			pix32 = *(CARD32 *)ptr;
			ptr += 4;
			x = *ptr++;
			y = *ptr++;
			w = *ptr++;
			h = *ptr++;
			gcv.foreground = pix32;
			XChangeGC(dpy, gc, GCForeground, &gcv);
			XFillRectangle(dpy, canvas, gc, rect.r.x + x,
				       rect.r.y + y, w, h);
		    }
		    break;
		}
		break;
	    }

	    case rfbEncodingHextile:
	    {
		switch (myFormat.bitsPerPixel) {
		case 8:
		    if (!HandleHextileEncoding8(rect.r.x, rect.r.y,
						rect.r.w, rect.r.h))
			return False;
		    break;
		case 16:
		    if (!HandleHextileEncoding16(rect.r.x, rect.r.y,
						 rect.r.w, rect.r.h))
			return False;
		    break;
		case 32:
		    if (!HandleHextileEncoding32(rect.r.x, rect.r.y,
						 rect.r.w, rect.r.h))
			return False;
		    break;
		}
		break;
	    }

	    default:
		fprintf(stderr,"%s: unknown rect encoding %d\n",programName,
		       (int)rect.encoding);
		return False;
	    }
	}

	sendUpdateRequest = True;

	break;
    }

    case rfbBell:
	XBell(dpy,100);
	break;

    case rfbServerCutText:
    {
#ifndef NANOX
	char *str;

	if (!ReadExact(rfbsock, ((char *)&msg) + 1,
			 sz_rfbServerCutTextMsg - 1))
	    return False;

	msg.sct.length = Swap32IfLE(msg.sct.length);

	str = malloc(msg.sct.length);

	if (!ReadExact(rfbsock, str, msg.sct.length))
	    return False;

	XSelectInput(dpy, DefaultRootWindow(dpy), 0);
	XStoreBytes(dpy, str, msg.sct.length);
	XSetSelectionOwner(dpy, XA_PRIMARY, None, CurrentTime);
	XSelectInput(dpy, DefaultRootWindow(dpy), PropertyChangeMask);

	free(str);
#endif /* !NANOX*/
	break;
    }

    default:
	fprintf(stderr,"%s: unknown message type %d from VNC server\n",
	       programName,msg.type);
	return False;
    }

    return True;
}


#define GET_PIXEL8(pix, ptr) ((pix) = *(ptr)++)

#define GET_PIXEL16(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \
			       ((CARD8*)&(pix))[1] = *(ptr)++)

#define GET_PIXEL32(pix, ptr) (((CARD8*)&(pix))[0] = *(ptr)++, \
			       ((CARD8*)&(pix))[1] = *(ptr)++, \
			       ((CARD8*)&(pix))[2] = *(ptr)++, \
			       ((CARD8*)&(pix))[3] = *(ptr)++)

#define DEFINE_HEXTILE(bpp)                                                   \
static Bool                                                                   \
HandleHextileEncoding##bpp(int rx, int ry, int rw, int rh)                    \
{                                                                             \
    CARD##bpp bg, fg;                                                         \
    XGCValues gcv;                                                            \
    int i;                                                                    \
    CARD8 *ptr;                                                               \
    int x, y, w, h;                                                           \
    int sx, sy, sw, sh;                                                       \
    CARD8 subencoding;                                                        \
    CARD8 nSubrects;                                                          \
                                                                              \
    for (y = ry; y < ry+rh; y += 16) {                                        \
        for (x = rx; x < rx+rw; x += 16) {                                    \
            w = h = 16;                                                       \
            if (rx+rw - x < 16)                                               \
                w = rx+rw - x;                                                \
            if (ry+rh - y < 16)                                               \
                h = ry+rh - y;                                                \
                                                                              \
            if (!ReadExact(rfbsock, (char *)&subencoding, 1))                 \
                return False;                                                 \
                                                                              \
            if (subencoding & rfbHextileRaw) {                                \
                if (!ReadExact(rfbsock, buffer, w * h * (bpp / 8)))           \
                    return False;                                             \
                                                                              \
                CopyDataToScreen((CARD8 *)buffer, x, y, w, h);                \
                continue;                                                     \
            }                                                                 \
                                                                              \
            if (subencoding & rfbHextileBackgroundSpecified)                  \
                if (!ReadExact(rfbsock, (char *)&bg, (bpp/8)))                \
                    return False;                                             \
                                                                              \
            if ((bpp == 8) && useBGR233)                                      \
                gcv.foreground = BGR233ToPixel[bg];                           \
            else                                                              \
                gcv.foreground = bg;                                          \
                                                                              \
            XChangeGC(dpy, gc, GCForeground, &gcv);                           \
            XFillRectangle(dpy, canvas, gc, x, y, w, h);                      \
                                                                              \
            if (subencoding & rfbHextileForegroundSpecified)                  \
                if (!ReadExact(rfbsock, (char *)&fg, (bpp/8)))                \
                    return False;                                             \
                                                                              \
            if (!(subencoding & rfbHextileAnySubrects)) {                     \
                continue;                                                     \
            }                                                                 \
                                                                              \
            if (!ReadExact(rfbsock, (char *)&nSubrects, 1))                   \
                return False;                                                 \
                                                                              \
            ptr = (CARD8 *)buffer;                                            \
                                                                              \
            if (subencoding & rfbHextileSubrectsColoured) {                   \
                if (!ReadExact(rfbsock, buffer, nSubrects * (2 + (bpp / 8)))) \
                    return False;                                             \
                                                                              \
                for (i = 0; i < nSubrects; i++) {                             \
                    GET_PIXEL##bpp(fg, ptr);                                  \
                    sx = rfbHextileExtractX(*ptr);                            \
                    sy = rfbHextileExtractY(*ptr);                            \
                    ptr++;                                                    \
                    sw = rfbHextileExtractW(*ptr);                            \
                    sh = rfbHextileExtractH(*ptr);                            \
                    ptr++;                                                    \
                    if ((bpp == 8) && useBGR233)                              \
                        gcv.foreground = BGR233ToPixel[fg];                   \
                    else                                                      \
                        gcv.foreground = fg;                                  \
                                                                              \
                    XChangeGC(dpy, gc, GCForeground, &gcv);                   \
                    XFillRectangle(dpy, canvas, gc, x+sx, y+sy, sw, sh);      \
                }                                                             \
                                                                              \
            } else {                                                          \
                if (!ReadExact(rfbsock, buffer, nSubrects * 2))               \
                    return False;                                             \
                                                                              \
                if ((bpp == 8) && useBGR233)                                  \
                    gcv.foreground = BGR233ToPixel[fg];                       \
                else                                                          \
                    gcv.foreground = fg;                                      \
                                                                              \
                XChangeGC(dpy, gc, GCForeground, &gcv);                       \
                                                                              \
                for (i = 0; i < nSubrects; i++) {                             \
                    sx = rfbHextileExtractX(*ptr);                            \
                    sy = rfbHextileExtractY(*ptr);                            \
                    ptr++;                                                    \
                    sw = rfbHextileExtractW(*ptr);                            \
                    sh = rfbHextileExtractH(*ptr);                            \
                    ptr++;                                                    \
                    XFillRectangle(dpy, canvas, gc, x+sx, y+sy, sw, sh);      \
                }                                                             \
            }                                                                 \
        }                                                                     \
    }                                                                         \
                                                                              \
    return True;                                                              \
}

DEFINE_HEXTILE(8)
DEFINE_HEXTILE(16)
DEFINE_HEXTILE(32)


/*
 * PrintPixelFormat.
 */

void
PrintPixelFormat(rfbPixelFormat *format)
{
    if (format->bitsPerPixel == 1) {
	fprintf(stderr,"Single bit per pixel.\n");
	fprintf(stderr,
		"%s significant bit in each byte is leftmost on the screen.\n",
		(format->bigEndian ? "Most" : "Least"));
    } else {
	fprintf(stderr,"%d bits per pixel.\n",format->bitsPerPixel);
	if (format->bitsPerPixel != 8) {
	    fprintf(stderr,"%s significant byte first in each pixel.\n",
		    (format->bigEndian ? "Most" : "Least"));
	}
	if (format->trueColour) {
	    fprintf(stderr,"True colour: max red %d green %d blue %d\n",
		    format->redMax, format->greenMax, format->blueMax);
	    fprintf(stderr,"            shift red %d green %d blue %d\n",
		    format->redShift, format->greenShift, format->blueShift);
	} else {
	    fprintf(stderr,"Uses a colour map (not true colour).\n");
	}
    }
}