1 /* 2 * scale.c - deal with server-side scaling. 3 */ 4 5 /* 6 * Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin 7 * Copyright (C) 2002 RealVNC Ltd. 8 * OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk (at) incompleteness.net>. 9 * Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge. 10 * All Rights Reserved. 11 * 12 * This is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This software is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this software; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 25 * USA. 26 */ 27 28 #ifdef __STRICT_ANSI__ 29 #define _BSD_SOURCE 30 #endif 31 #include <string.h> 32 #include <rfb/rfb.h> 33 #include <rfb/rfbregion.h> 34 #include "private.h" 35 36 #ifdef LIBVNCSERVER_HAVE_FCNTL_H 37 #include <fcntl.h> 38 #endif 39 40 #ifdef WIN32 41 #define write(sock,buf,len) send(sock,buf,len,0) 42 #else 43 #ifdef LIBVNCSERVER_HAVE_UNISTD_H 44 #include <unistd.h> 45 #endif 46 #include <pwd.h> 47 #ifdef LIBVNCSERVER_HAVE_SYS_SOCKET_H 48 #include <sys/socket.h> 49 #endif 50 #ifdef LIBVNCSERVER_HAVE_NETINET_IN_H 51 #include <netinet/in.h> 52 #include <netinet/tcp.h> 53 #include <arpa/inet.h> 54 #endif 55 #endif 56 57 #ifdef DEBUGPROTO 58 #undef DEBUGPROTO 59 #define DEBUGPROTO(x) x 60 #else 61 #define DEBUGPROTO(x) 62 #endif 63 64 /****************************/ 65 #define CEIL(x) ( (double) ((int) (x)) == (x) ? \ 66 (double) ((int) (x)) : (double) ((int) (x) + 1) ) 67 #define FLOOR(x) ( (double) ((int) (x)) ) 68 69 static inline int pad4(int value) 70 { 71 int remainder = value & 3; 72 if (!remainder) return value; 73 return value + 4 - remainder; 74 } 75 76 int ScaleX(rfbScreenInfoPtr from, rfbScreenInfoPtr to, int x) 77 { 78 if ((from==to) || (from==NULL) || (to==NULL)) return x; 79 return ((int)(((double) x / (double)from->width) * (double)to->width )); 80 } 81 82 int ScaleY(rfbScreenInfoPtr from, rfbScreenInfoPtr to, int y) 83 { 84 if ((from==to) || (from==NULL) || (to==NULL)) return y; 85 return ((int)(((double) y / (double)from->height) * (double)to->height )); 86 } 87 88 /* So, all of the encodings point to the ->screen->frameBuffer, 89 * We need to change this! 90 */ 91 void rfbScaledCorrection(rfbScreenInfoPtr from, rfbScreenInfoPtr to, int *x, int *y, int *w, int *h, const char *function) 92 { 93 double x1,y1,w1,h1, x2, y2, w2, h2; 94 double scaleW = ((double) to->width) / ((double) from->width); 95 double scaleH = ((double) to->height) / ((double) from->height); 96 97 98 /* 99 * rfbLog("rfbScaledCorrection(%p -> %p, %dx%d->%dx%d (%dXx%dY-%dWx%dH)\n", 100 * from, to, from->width, from->height, to->width, to->height, *x, *y, *w, *h); 101 */ 102 103 /* If it's the original framebuffer... */ 104 if (from==to) return; 105 106 x1 = ((double) *x) * scaleW; 107 y1 = ((double) *y) * scaleH; 108 w1 = ((double) *w) * scaleW; 109 h1 = ((double) *h) * scaleH; 110 111 112 /*cast from double to int is same as "*x = floor(x1);" */ 113 x2 = FLOOR(x1); 114 y2 = FLOOR(y1); 115 116 /* include into W and H the jitter of scaling X and Y */ 117 w2 = CEIL(w1 + ( x1 - x2 )); 118 h2 = CEIL(h1 + ( y1 - y2 )); 119 120 /* 121 * rfbLog("%s (%dXx%dY-%dWx%dH -> %fXx%fY-%fWx%fH) {%dWx%dH -> %dWx%dH}\n", 122 * function, *x, *y, *w, *h, x2, y2, w2, h2, 123 * from->width, from->height, to->width, to->height); 124 */ 125 126 /* simulate ceil() without math library */ 127 *x = (int)x2; 128 *y = (int)y2; 129 *w = (int)w2; 130 *h = (int)h2; 131 132 /* Small changes for a thumbnail may be scaled to zero */ 133 if (*w==0) (*w)++; 134 if (*h==0) (*h)++; 135 /* scaling from small to big may overstep the size a bit */ 136 if (*x+*w > to->width) *w=to->width - *x; 137 if (*y+*h > to->height) *h=to->height - *y; 138 } 139 140 void rfbScaledScreenUpdateRect(rfbScreenInfoPtr screen, rfbScreenInfoPtr ptr, int x0, int y0, int w0, int h0) 141 { 142 int x,y,w,v,z; 143 int x1, y1, w1, h1; 144 int bitsPerPixel, bytesPerPixel, bytesPerLine, areaX, areaY, area2; 145 unsigned char *srcptr, *dstptr; 146 147 /* Nothing to do!!! */ 148 if (screen==ptr) return; 149 150 x1 = x0; 151 y1 = y0; 152 w1 = w0; 153 h1 = h0; 154 155 rfbScaledCorrection(screen, ptr, &x1, &y1, &w1, &h1, "rfbScaledScreenUpdateRect"); 156 x0 = ScaleX(ptr, screen, x1); 157 y0 = ScaleY(ptr, screen, y1); 158 w0 = ScaleX(ptr, screen, w1); 159 h0 = ScaleY(ptr, screen, h1); 160 161 bitsPerPixel = screen->bitsPerPixel; 162 bytesPerPixel = bitsPerPixel / 8; 163 bytesPerLine = w1 * bytesPerPixel; 164 srcptr = (unsigned char *)(screen->frameBuffer + 165 (y0 * screen->paddedWidthInBytes + x0 * bytesPerPixel)); 166 dstptr = (unsigned char *)(ptr->frameBuffer + 167 ( y1 * ptr->paddedWidthInBytes + x1 * bytesPerPixel)); 168 /* The area of the source framebuffer for each destination pixel */ 169 areaX = ScaleX(ptr,screen,1); 170 areaY = ScaleY(ptr,screen,1); 171 area2 = areaX*areaY; 172 173 174 /* Ensure that we do not go out of bounds */ 175 if ((x1+w1) > (ptr->width)) 176 { 177 if (x1==0) w1=ptr->width; else x1 = ptr->width - w1; 178 } 179 if ((y1+h1) > (ptr->height)) 180 { 181 if (y1==0) h1=ptr->height; else y1 = ptr->height - h1; 182 } 183 /* 184 * rfbLog("rfbScaledScreenUpdateRect(%dXx%dY-%dWx%dH -> %dXx%dY-%dWx%dH <%dx%d>) {%dWx%dH -> %dWx%dH} 0x%p\n", 185 * x0, y0, w0, h0, x1, y1, w1, h1, areaX, areaY, 186 * screen->width, screen->height, ptr->width, ptr->height, ptr->frameBuffer); 187 */ 188 189 if (screen->serverFormat.trueColour) { /* Blend neighbouring pixels together */ 190 unsigned char *srcptr2; 191 unsigned long pixel_value, red, green, blue; 192 unsigned int redShift = screen->serverFormat.redShift; 193 unsigned int greenShift = screen->serverFormat.greenShift; 194 unsigned int blueShift = screen->serverFormat.blueShift; 195 unsigned long redMax = screen->serverFormat.redMax; 196 unsigned long greenMax = screen->serverFormat.greenMax; 197 unsigned long blueMax = screen->serverFormat.blueMax; 198 199 /* for each *destination* pixel... */ 200 for (y = 0; y < h1; y++) { 201 for (x = 0; x < w1; x++) { 202 red = green = blue = 0; 203 /* Get the totals for rgb from the source grid... */ 204 for (w = 0; w < areaX; w++) { 205 for (v = 0; v < areaY; v++) { 206 srcptr2 = &srcptr[(((x * areaX) + w) * bytesPerPixel) + 207 (v * screen->paddedWidthInBytes)]; 208 pixel_value = 0; 209 210 211 switch (bytesPerPixel) { 212 case 4: pixel_value = *((unsigned int *)srcptr2); break; 213 case 2: pixel_value = *((unsigned short *)srcptr2); break; 214 case 1: pixel_value = *((unsigned char *)srcptr2); break; 215 default: 216 /* fixme: endianess problem? */ 217 for (z = 0; z < bytesPerPixel; z++) 218 pixel_value += (srcptr2[z] << (8 * z)); 219 break; 220 } 221 /* 222 srcptr2 += bytesPerPixel; 223 */ 224 225 red += ((pixel_value >> redShift) & redMax); 226 green += ((pixel_value >> greenShift) & greenMax); 227 blue += ((pixel_value >> blueShift) & blueMax); 228 229 } 230 } 231 /* We now have a total for all of the colors, find the average! */ 232 red /= area2; 233 green /= area2; 234 blue /= area2; 235 /* Stuff the new value back into memory */ 236 pixel_value = ((red & redMax) << redShift) | ((green & greenMax) << greenShift) | ((blue & blueMax) << blueShift); 237 238 switch (bytesPerPixel) { 239 case 4: *((unsigned int *)dstptr) = (unsigned int) pixel_value; break; 240 case 2: *((unsigned short *)dstptr) = (unsigned short) pixel_value; break; 241 case 1: *((unsigned char *)dstptr) = (unsigned char) pixel_value; break; 242 default: 243 /* fixme: endianess problem? */ 244 for (z = 0; z < bytesPerPixel; z++) 245 dstptr[z]=(pixel_value >> (8 * z)) & 0xff; 246 break; 247 } 248 dstptr += bytesPerPixel; 249 } 250 srcptr += (screen->paddedWidthInBytes * areaY); 251 dstptr += (ptr->paddedWidthInBytes - bytesPerLine); 252 } 253 } else 254 { /* Not truecolour, so we can't blend. Just use the top-left pixel instead */ 255 for (y = y1; y < (y1+h1); y++) { 256 for (x = x1; x < (x1+w1); x++) 257 memcpy (&ptr->frameBuffer[(y *ptr->paddedWidthInBytes) + (x * bytesPerPixel)], 258 &screen->frameBuffer[(y * areaY * screen->paddedWidthInBytes) + (x *areaX * bytesPerPixel)], bytesPerPixel); 259 } 260 } 261 } 262 263 void rfbScaledScreenUpdate(rfbScreenInfoPtr screen, int x1, int y1, int x2, int y2) 264 { 265 /* ok, now the task is to update each and every scaled version of the framebuffer 266 * and we only have to do this for this specific changed rectangle! 267 */ 268 rfbScreenInfoPtr ptr; 269 int count=0; 270 271 /* We don't point to cl->screen as it is the original */ 272 for (ptr=screen->scaledScreenNext;ptr!=NULL;ptr=ptr->scaledScreenNext) 273 { 274 /* Only update if it has active clients... */ 275 if (ptr->scaledScreenRefCount>0) 276 { 277 rfbScaledScreenUpdateRect(screen, ptr, x1, y1, x2-x1, y2-y1); 278 count++; 279 } 280 } 281 } 282 283 /* Create a new scaled version of the framebuffer */ 284 rfbScreenInfoPtr rfbScaledScreenAllocate(rfbClientPtr cl, int width, int height) 285 { 286 rfbScreenInfoPtr ptr; 287 ptr = malloc(sizeof(rfbScreenInfo)); 288 if (ptr!=NULL) 289 { 290 int allocSize; 291 292 /* copy *everything* (we don't use most of it, but just in case) */ 293 memcpy(ptr, cl->screen, sizeof(rfbScreenInfo)); 294 295 /* SECURITY: make sure that no integer overflow will occur afterwards. 296 * Note: this is defensive coding, as the check should have already been 297 * performed during initial, non-scaled screen setup. 298 */ 299 allocSize = pad4(width * (ptr->bitsPerPixel/8)); /* per protocol, width<2**16 and bpp<256 */ 300 if (height == 0 || allocSize >= SIZE_MAX / height) 301 { 302 free(ptr); 303 return NULL; /* malloc() will allocate an incorrect buffer size - early abort */ 304 } 305 306 /* Resume copy everything */ 307 ptr->width = width; 308 ptr->height = height; 309 ptr->paddedWidthInBytes = (ptr->bitsPerPixel/8)*ptr->width; 310 311 /* Need to by multiples of 4 for Sparc systems */ 312 ptr->paddedWidthInBytes = pad4(ptr->paddedWidthInBytes); 313 314 /* Reset the reference count to 0! */ 315 ptr->scaledScreenRefCount = 0; 316 317 ptr->sizeInBytes = ptr->paddedWidthInBytes * ptr->height; 318 ptr->serverFormat = cl->screen->serverFormat; 319 320 ptr->frameBuffer = malloc(ptr->sizeInBytes); 321 if (ptr->frameBuffer!=NULL) 322 { 323 /* Reset to a known condition: scale the entire framebuffer */ 324 rfbScaledScreenUpdateRect(cl->screen, ptr, 0, 0, cl->screen->width, cl->screen->height); 325 /* Now, insert into the chain */ 326 LOCK(cl->updateMutex); 327 ptr->scaledScreenNext = cl->screen->scaledScreenNext; 328 cl->screen->scaledScreenNext = ptr; 329 UNLOCK(cl->updateMutex); 330 } 331 else 332 { 333 /* Failed to malloc the new frameBuffer, cleanup */ 334 free(ptr); 335 ptr=NULL; 336 } 337 } 338 return ptr; 339 } 340 341 /* Find an active scaled version of the framebuffer 342 * TODO: implement a refcount per scaled screen to prevent 343 * unreferenced scaled screens from hanging around 344 */ 345 rfbScreenInfoPtr rfbScalingFind(rfbClientPtr cl, int width, int height) 346 { 347 rfbScreenInfoPtr ptr; 348 /* include the original in the search (ie: fine 1:1 scaled version of the frameBuffer) */ 349 for (ptr=cl->screen; ptr!=NULL; ptr=ptr->scaledScreenNext) 350 { 351 if ((ptr->width==width) && (ptr->height==height)) 352 return ptr; 353 } 354 return NULL; 355 } 356 357 /* Future needs "scale to 320x240, as that's the client's screen size */ 358 void rfbScalingSetup(rfbClientPtr cl, int width, int height) 359 { 360 rfbScreenInfoPtr ptr; 361 362 ptr = rfbScalingFind(cl,width,height); 363 if (ptr==NULL) 364 ptr = rfbScaledScreenAllocate(cl,width,height); 365 /* Now, there is a new screen available (if ptr is not NULL) */ 366 if (ptr!=NULL) 367 { 368 /* Update it! */ 369 if (ptr->scaledScreenRefCount<1) 370 rfbScaledScreenUpdateRect(cl->screen, ptr, 0, 0, cl->screen->width, cl->screen->height); 371 /* 372 * rfbLog("Taking one from %dx%d-%d and adding it to %dx%d-%d\n", 373 * cl->scaledScreen->width, cl->scaledScreen->height, 374 * cl->scaledScreen->scaledScreenRefCount, 375 * ptr->width, ptr->height, ptr->scaledScreenRefCount); 376 */ 377 378 LOCK(cl->updateMutex); 379 cl->scaledScreen->scaledScreenRefCount--; 380 ptr->scaledScreenRefCount++; 381 cl->scaledScreen=ptr; 382 cl->newFBSizePending = TRUE; 383 UNLOCK(cl->updateMutex); 384 385 rfbLog("Scaling to %dx%d (refcount=%d)\n",width,height,ptr->scaledScreenRefCount); 386 } 387 else 388 rfbLog("Scaling to %dx%d failed, leaving things alone\n",width,height); 389 } 390 391 int rfbSendNewScaleSize(rfbClientPtr cl) 392 { 393 /* if the client supports newFBsize Encoding, use it */ 394 if (cl->useNewFBSize && cl->newFBSizePending) 395 return FALSE; 396 397 LOCK(cl->updateMutex); 398 cl->newFBSizePending = FALSE; 399 UNLOCK(cl->updateMutex); 400 401 if (cl->PalmVNC==TRUE) 402 { 403 rfbPalmVNCReSizeFrameBufferMsg pmsg; 404 pmsg.type = rfbPalmVNCReSizeFrameBuffer; 405 pmsg.pad1 = 0; 406 pmsg.desktop_w = Swap16IfLE(cl->screen->width); 407 pmsg.desktop_h = Swap16IfLE(cl->screen->height); 408 pmsg.buffer_w = Swap16IfLE(cl->scaledScreen->width); 409 pmsg.buffer_h = Swap16IfLE(cl->scaledScreen->height); 410 pmsg.pad2 = 0; 411 412 rfbLog("Sending a response to a PalmVNC style frameuffer resize event (%dx%d)\n", cl->scaledScreen->width, cl->scaledScreen->height); 413 if (rfbWriteExact(cl, (char *)&pmsg, sz_rfbPalmVNCReSizeFrameBufferMsg) < 0) { 414 rfbLogPerror("rfbNewClient: write"); 415 rfbCloseClient(cl); 416 return FALSE; 417 } 418 } 419 else 420 { 421 rfbResizeFrameBufferMsg rmsg; 422 rmsg.type = rfbResizeFrameBuffer; 423 rmsg.pad1=0; 424 rmsg.framebufferWidth = Swap16IfLE(cl->scaledScreen->width); 425 rmsg.framebufferHeigth = Swap16IfLE(cl->scaledScreen->height); 426 rfbLog("Sending a response to a UltraVNC style frameuffer resize event (%dx%d)\n", cl->scaledScreen->width, cl->scaledScreen->height); 427 if (rfbWriteExact(cl, (char *)&rmsg, sz_rfbResizeFrameBufferMsg) < 0) { 428 rfbLogPerror("rfbNewClient: write"); 429 rfbCloseClient(cl); 430 return FALSE; 431 } 432 } 433 return TRUE; 434 } 435 /****************************/ 436