util/mag_image.c

   1 #include "mag_image.h"
   2
   3
   4 static int get_num(char* msg);
   5 static void get_coord(char* msg,point *p);
   6 static void get_rect(char* msg, point *p1, point *p2);
   7 static void compute_center_coord(point p1, point p2, point *center);
   8 static xlib_colormap * xlib_get_colormap (Colormap id, Visual *visual, MagnifierData *data);
   9 static guint32 mask_table[] = {
  10         0x00000000, 0x00000001, 0x00000003, 0x00000007,
  11         0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
  12         0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
  13         0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
  14         0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
  15         0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
  16         0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
  17         0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
  18         0xffffffff
  19 };
  20
  21 void parse_message(char *msg, MagnifierData *data){
  22
  23   int type;
  24   point roi_pos, roi_size;
  25   point mag_pos, mag_size;
  26
  27   printf("%s\n",msg);
  28   if(msg[0] != '~'){
  29     fprintf(stderr,"corrupted message, discarding\n");
  30     return;
  31   }
  32   type = atoi((char*)&msg[1]);
  33   switch (type){
  34         case FACTOR :
  35             old_factor_x = data->factor_x;
  36             data->factor_x = get_num(msg);
  37             old_factor_y = data->factor_y;
  38             data->factor_y = get_num(msg);
  39             printf("FACTOR = %d\n",data->factor_x);
  40             break;
  41         case CONTRAST :
  42             data->contrast = get_num(msg);
  43             printf("CONTRAST = %d\n",data->contrast);
  44             break;
  45         case FOLLOW_MOUSE :
  46             data->follow_mouse = get_num(msg);
  47             printf("FOLLOW_MOUSE = %d\n",data->follow_mouse);
  48             break;
  49         case COLOR_INVERTED :
  50             data->color_inverted = get_num(msg);
  51             printf("COLOR_INVERTED = %d\n",data->color_inverted);
  52             break;
  53         case GOTO :
  54             get_coord(msg, &data->center);
  55             printf("GOTO = (%d,%d)\n", data->center.x, data->center.y);
  56             break;
  57         case SET_ROI:
  58             get_rect (msg, &roi_pos, &roi_size);
  59             printf("ROI = (%d,%d; %d,%d)\n", roi_pos.x, roi_pos.y, roi_size.x, roi_size.y);
  60             compute_center_coord (roi_pos, roi_size, &data->center);
  61             break;
  62         case SET_EXTENTS:
  63             get_rect (msg, &mag_pos, &mag_size);
  64             printf("EXTENTS = (%d,%d; %d,%d)\n", mag_pos.x, mag_pos.y, mag_size.x, mag_size.y);
  65             data->mag_width = mag_size.x;
  66             data->mag_height = mag_size.y;
  67             gdk_window_move_resize (data->output_window->window, mag_pos.x,
  68                                     mag_pos.y,
  69                                     data->mag_width, data->mag_height);
  70             break;
  71         case STOP :
  72             printf("STOP\n");
  73             gtk_main_quit();
  74             break;
  75         default:
  76             break;
  77   }
  78 }
  79
  80
  81 static int get_num(char* msg){
  82  int type,num;
  83  sscanf(msg,"~%d:%d:",&type,&num);
  84  return num;
  85 }
  86
  87 static void get_coord(char* msg,point *p){
  88  int type;
  89  sscanf(msg,"~%d:%d,%d:",&type,&p->x,&p->y);
  90 }
  91
  92 static void get_rect(char* msg, point *p1, point *p2){
  93  int type;
  94  sscanf(msg,"~%d:%d,%d;%d,%d:",&type, &p1->x, &p1->y, &p2->x, &p2->y);
  95 }
  96
  97 static void compute_center_coord (point pos, point size, point *center) {
  98   center->x = pos.x + (size.x/2);
  99   center->y = pos.y + (size.y/2);
 100 }
 101
 102 int display_image(gpointer data)
 103 {
 104   MagnifierData *mag_data = (MagnifierData *)data;
 105   update_image(mag_data);
 106   gdk_pixbuf_scale(image,
 107                    scaled_image,
 108                    0,
 109                    0,
 110                    DisplayWidth (mag_data->target_display,screen_num),
 111                    DisplayHeight(mag_data->target_display,screen_num),
 112                    0,
 113                    0,
 114                    mag_data->factor_x,
 115                    mag_data->factor_y,
 116                    GDK_INTERP_NEAREST);
 117
 118   gdk_pixbuf_render_to_drawable (scaled_image,
 119                         drawing_area->window,
 120                         drawing_area->style->fg_gc[GTK_STATE_NORMAL],
 121                         0,0,0,0,DisplayWidth (mag_data->target_display,screen_num),
 122                         DisplayHeight(mag_data->target_display,screen_num),
 123                         GDK_RGB_DITHER_NORMAL,0,0);
 124   return TRUE;
 125 }
 126
 127 void update_image(MagnifierData *mag_data)
 128 {
 129  int x, y, total_width, total_height;
 130
 131  if(mag_data->follow_mouse){
 132     Window root_return, child_return;
 133     int win_x_return,win_y_return;
 134     unsigned int mask_return;
 135     XQueryPointer(mag_data->source_display,spi_image_root_window,
 136                   &root_return,&child_return,
 137                   &mag_data->center.x,&mag_data->center.y,
 138                   &win_x_return,&win_y_return,&mask_return);
 139   }
 140
 141   total_width = DisplayWidth (mag_data->source_display,screen_num);
 142   total_height = DisplayHeight(mag_data->source_display,screen_num);
 143
 144   x = mag_data->center.x - mag_data->mag_width/mag_data->factor_x/2;
 145   y = mag_data->center.y - mag_data->mag_height/mag_data->factor_y/2;
 146
 147   if(mag_data->center.x < mag_data->mag_width/mag_data->factor_x/2)
 148     x = 0;
 149   if(mag_data->center.x > (total_width - mag_data->mag_width/mag_data->factor_x/2))
 150     x = total_width - mag_data->mag_width/mag_data->factor_x;
 151   if(mag_data->center.y < mag_data->mag_height/mag_data->factor_y/2)
 152     y = 0;
 153   if(mag_data->center.y > (total_height - mag_data->mag_height/mag_data->factor_y/2))
 154     y = total_height - mag_data->mag_height/mag_data->factor_y;
 155   if(x < 0)
 156     x = 0;
 157   if(y < 0)
 158     y = 0;
 159 /*
 160   printf("p = (%d,%d), x,y = (%d,%d), h,w = (%d,%d), ht,wt = (%d,%d)\n",
 161                                         mag_data->center.x,
 162                                         mag_data->center.y,
 163                                         x,y,
 164                                         mag_data->mag_height,mag_data->mag_width,
 165                                         total_height,
 166                                         total_width);
 167 */
 168   if(mag_data->factor_x != old_factor_x || mag_data->factor_y != old_factor_y){
 169     g_object_unref((GObject *)image);
 170     image = gdk_pixbuf_new (GDK_COLORSPACE_RGB,FALSE, 8,
 171                                 DisplayWidth (mag_data->target_display,screen_num)/mag_data->factor_x,
 172                                 DisplayHeight(mag_data->target_display,screen_num)/mag_data->factor_y);
 173     /* yes, use target display above, since the size of the area grabbed depends on the target */
 174     old_factor_x = mag_data->factor_x;
 175     old_factor_y = mag_data->factor_y;
 176   }
 177   get_root_image(spi_image_root_window,
 178                  image,
 179                  x,
 180                  y,
 181                  mag_data);
 182 }
 183 void expose_event(GtkWidget * w, GdkEventExpose *event, gpointer data){
 184
 185 }
 186
 187
 188
 189
 190 /* SpiImage grabbing and convertion routines from gdk-pixbuf-xlib */
 191 /*
 192   convert 1 bits-pixel data
 193   no alpha
 194 */
 195 static void
 196 rgb1 (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 197 {
 198         int xx, yy;
 199         int width, height;
 200         int bpl;
 201         guint8 *s;
 202         register guint8 data;
 203         guint8 *o;
 204         guint8 *srow = image->data, *orow = pixels;
 205
 206         /* convert upto 8 pixels/time */
 207         /* its probably not worth trying to make this run very fast, who uses
 208            1 bit displays anymore? */
 209         width = image->width;
 210         height = image->height;
 211         bpl = image->bytes_per_line;
 212
 213         for (yy = 0; yy < height; yy++) {
 214                 s = srow;
 215                 o = orow;
 216
 217                 for (xx = 0; xx < width; xx ++) {
 218                         data = srow[xx >> 3] >> (7 - (xx & 7)) & 1;
 219                         *o++ = colormap->colors[data].red;
 220                         *o++ = colormap->colors[data].green;
 221                         *o++ = colormap->colors[data].blue;
 222                 }
 223                 srow += bpl;
 224                 orow += rowstride;
 225         }
 226 }
 227
 228 /*
 229   convert 1 bits/pixel data
 230   with alpha
 231 */
 232 static void
 233 rgb1a (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 234 {
 235         int xx, yy;
 236         int width, height;
 237         int bpl;
 238         guint8 *s;
 239         register guint8 data;
 240         guint8 *o;
 241         guint8 *srow = image->data, *orow = pixels;
 242         guint32 remap[2];
 243
 244         /* convert upto 8 pixels/time */
 245         /* its probably not worth trying to make this run very fast, who uses
 246            1 bit displays anymore? */
 247         width = image->width;
 248         height = image->height;
 249         bpl = image->bytes_per_line;
 250
 251         for (xx = 0; xx < 2; xx++) {
 252 #ifdef LITTLE
 253                 remap[xx] = 0xff000000
 254                         | colormap->colors[xx].blue << 16
 255                         | colormap->colors[xx].green << 8
 256                         | colormap->colors[xx].red;
 257 #else
 258                 remap[xx] = 0xff
 259                         | colormap->colors[xx].red << 24
 260                         | colormap->colors[xx].green << 16
 261                         | colormap->colors[xx].blue << 8;
 262 #endif
 263         }
 264
 265         for (yy = 0; yy < height; yy++) {
 266                 s = srow;
 267                 o = orow;
 268
 269                 for (xx = 0; xx < width; xx ++) {
 270                         data = srow[xx >> 3] >> (7 - (xx & 7)) & 1;
 271                         *o++ = remap[data];
 272                 }
 273                 srow += bpl;
 274                 orow += rowstride;
 275         }
 276 }
 277
 278 /*
 279   convert 8 bits/pixel data
 280   no alpha
 281 */
 282 static void
 283 rgb8 (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 284 {
 285         int xx, yy;
 286         int width, height;
 287         int bpl;
 288         guint32 mask;
 289         register guint32 data;
 290         guint8 *srow = image->data, *orow = pixels;
 291         register guint8 *s;
 292         register guint8 *o;
 293
 294         width = image->width;
 295         height = image->height;
 296         bpl = image->bytes_per_line;
 297
 298         mask = mask_table[image->depth];
 299
 300         for (yy = 0; yy < height; yy++) {
 301                 s = srow;
 302                 o = orow;
 303                 for (xx = 0; xx < width; xx++) {
 304                         data = *s++ & mask;
 305                         *o++ = colormap->colors[data].red;
 306                         *o++ = colormap->colors[data].green;
 307                         *o++ = colormap->colors[data].blue;
 308                 }
 309                 srow += bpl;
 310                 orow += rowstride;
 311         }
 312 }
 313
 314 /*
 315   convert 8 bits/pixel data
 316   with alpha
 317 */
 318 static void
 319 rgb8a (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 320 {
 321         int xx, yy;
 322         int width, height;
 323         int bpl;
 324         guint32 mask;
 325         register guint32 data;
 326         guint32 remap[256];
 327         register guint8 *s;     /* read 2 pixels at once */
 328         register guint32 *o;
 329         guint8 *srow = image->data, *orow = pixels;
 330
 331         width = image->width;
 332         height = image->height;
 333         bpl = image->bytes_per_line;
 334
 335         mask = mask_table[image->depth];
 336
 337         for (xx = 0; xx < colormap->size; xx++) {
 338 #ifdef LITTLE
 339                 remap[xx] = 0xff000000
 340                         | colormap->colors[xx].blue << 16
 341                         | colormap->colors[xx].green << 8
 342                         | colormap->colors[xx].red;
 343 #else
 344                 remap[xx] = 0xff
 345                         | colormap->colors[xx].red << 24
 346                         | colormap->colors[xx].green << 16
 347                         | colormap->colors[xx].blue << 8;
 348 #endif
 349         }
 350
 351         for (yy = 0; yy < height; yy++) {
 352                 s = srow;
 353                 o = (guint32 *) orow;
 354                 for (xx = 0; xx < width; xx ++) {
 355                         data = *s++ & mask;
 356                         *o++ = remap[data];
 357                 }
 358                 srow += bpl;
 359                 orow += rowstride;
 360         }
 361 }
 362
 363 /*
 364   convert 16 bits/pixel data
 365   no alpha
 366   data in lsb format
 367 */
 368 static void
 369 rgb565lsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 370 {
 371         int xx, yy;
 372         int width, height;
 373         int bpl;
 374
 375 #ifdef LITTLE
 376         register guint32 *s;    /* read 2 pixels at once */
 377 #else
 378         register guint8 *s;     /* read 2 pixels at once */
 379 #endif
 380         register guint16 *o;
 381         guint8 *srow = image->data, *orow = pixels;
 382
 383         width = image->width;
 384         height = image->height;
 385         bpl = image->bytes_per_line;
 386
 387         for (yy = 0; yy < height; yy++) {
 388 #ifdef LITTLE
 389                 s = (guint32 *) srow;
 390 #else
 391                 s = srow;
 392 #endif
 393                 o = (guint16 *) orow;
 394                 for (xx = 1; xx < width; xx += 2) {
 395                         register guint32 data;
 396 #ifdef LITTLE
 397                         data = *s++;
 398                         *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13
 399                                 | (data & 0x7e0) << 5 | (data & 0x600) >> 1;
 400                         *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2
 401                                 | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21;
 402                         *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25
 403                                 | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10;
 404 #else
 405                         /* swap endianness first */
 406                         data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
 407                         s += 4;
 408                         *o++ = (data & 0xf800) | (data & 0xe000) >> 5
 409                                 | (data & 0x7e0) >> 3 | (data & 0x600) >> 9;
 410                         *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6
 411                                 | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29;
 412                         *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17
 413                                 | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18;
 414 #endif
 415                 }
 416                 /* check for last remaining pixel */
 417                 if (width & 1) {
 418                         register guint16 data;
 419 #ifdef LITTLE
 420                         data = *((short *) s);
 421 #else
 422                         data = *((short *) s);
 423                         data = ((data >> 8) & 0xff) | ((data & 0xff) << 8);
 424 #endif
 425                         ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7);
 426                         ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3);
 427                         ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7);
 428                 }
 429                 srow += bpl;
 430                 orow += rowstride;
 431         }
 432 }
 433
 434 /*
 435   convert 16 bits/pixel data
 436   no alpha
 437   data in msb format
 438 */
 439 static void
 440 rgb565msb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 441 {
 442         int xx, yy;
 443         int width, height;
 444         int bpl;
 445
 446 #ifdef LITTLE
 447         register guint8 *s;     /* need to swap data order */
 448 #else
 449         register guint32 *s;    /* read 2 pixels at once */
 450 #endif
 451         register guint16 *o;
 452         guint8 *srow = image->data, *orow = pixels;
 453
 454         width = image->width;
 455         height = image->height;
 456         bpl = image->bytes_per_line;
 457
 458         for (yy = 0; yy < height; yy++) {
 459 #ifdef LITTLE
 460                 s = srow;
 461 #else
 462                 s = (guint32 *) srow;
 463 #endif
 464                 o = (guint16 *) orow;
 465                 for (xx = 1; xx < width; xx += 2) {
 466                         register guint32 data;
 467 #ifdef LITTLE
 468                         /* swap endianness first */
 469                         data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
 470                         s += 4;
 471                         *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13
 472                                 | (data & 0x7e0) << 5 | (data & 0x600) >> 1;
 473                         *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2
 474                                 | (data & 0xf8000000) >> 16 | (data & 0xe0000000) >> 21;
 475                         *o++ = (data & 0x7e00000) >> 19 | (data & 0x6000000) >> 25
 476                                 | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10;
 477 #else
 478                         data = *s++;
 479                         *o++ = (data & 0xf800) | (data & 0xe000) >> 5
 480                                 | (data & 0x7e0) >> 3 | (data & 0x600) >> 9;
 481                         *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6
 482                                 | (data & 0xf8000000) >> 24 | (data & 0xe0000000) >> 29;
 483                         *o++ = (data & 0x7e00000) >> 11 | (data & 0x6000000) >> 17
 484                                 | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18;
 485 #endif
 486                 }
 487                 /* check for last remaining pixel */
 488                 if (width & 1) {
 489                         register guint16 data;
 490 #ifdef LITTLE
 491                         data = *((short *) s);
 492                         data = ((data >> 8) & 0xff) | ((data & 0xff) << 8);
 493 #else
 494                         data = *((short *) s);
 495 #endif
 496                         ((char *) o)[0] = ((data >> 8) & 0xf8) | ((data >> 13) & 0x7);
 497                         ((char *) o)[1] = ((data >> 3) & 0xfc) | ((data >> 9) & 0x3);
 498                         ((char *) o)[2] = ((data << 3) & 0xf8) | ((data >> 2) & 0x7);
 499                 }
 500                 srow += bpl;
 501                 orow += rowstride;
 502         }
 503 }
 504
 505 /*
 506   convert 16 bits/pixel data
 507   with alpha
 508   data in lsb format
 509 */
 510 static void
 511 rgb565alsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 512 {
 513         int xx, yy;
 514         int width, height;
 515         int bpl;
 516
 517 #ifdef LITTLE
 518         register guint16 *s;    /* read 1 pixels at once */
 519 #else
 520         register guint8 *s;
 521 #endif
 522         register guint32 *o;
 523
 524         guint8 *srow = image->data, *orow = pixels;
 525
 526         width = image->width;
 527         height = image->height;
 528         bpl = image->bytes_per_line;
 529
 530         for (yy = 0; yy < height; yy++) {
 531 #ifdef LITTLE
 532                 s = (guint16 *) srow;
 533 #else
 534                 s = (guint8 *) srow;
 535 #endif
 536                 o = (guint32 *) orow;
 537                 for (xx = 0; xx < width; xx ++) {
 538                         register guint32 data;
 539                         /*  rrrrrggg gggbbbbb -> rrrrrRRR ggggggGG bbbbbBBB aaaaaaaa */
 540                         /*  little endian: aaaaaaaa bbbbbBBB ggggggGG rrrrrRRR */
 541 #ifdef LITTLE
 542                         data = *s++;
 543                         *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13
 544                                 | (data & 0x7e0) << 5 | (data & 0x600) >> 1
 545                                 | (data & 0x1f) << 19 | (data & 0x1c) << 14
 546                                 | 0xff000000;
 547 #else
 548                         /* swap endianness first */
 549                         data = s[0] | s[1] << 8;
 550                         s += 2;
 551                         *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11
 552                                 | (data & 0x7e0) << 13 | (data & 0x600) << 7
 553                                 | (data & 0x1f) << 11 | (data & 0x1c) << 6
 554                                 | 0xff;
 555 #endif
 556                 }
 557                 srow += bpl;
 558                 orow += rowstride;
 559         }
 560 }
 561
 562 /*
 563   convert 16 bits/pixel data
 564   with alpha
 565   data in msb format
 566 */
 567 static void
 568 rgb565amsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 569 {
 570         int xx, yy;
 571         int width, height;
 572         int bpl;
 573
 574 #ifdef LITTLE
 575         register guint8 *s;
 576 #else
 577         register guint16 *s;    /* read 1 pixels at once */
 578 #endif
 579         register guint32 *o;
 580
 581         guint8 *srow = image->data, *orow = pixels;
 582
 583         width = image->width;
 584         height = image->height;
 585         bpl = image->bytes_per_line;
 586
 587         for (yy = 0; yy < height; yy++) {
 588                 s = srow;
 589                 o = (guint32 *) orow;
 590                 for (xx = 0; xx < width; xx ++) {
 591                         register guint32 data;
 592                         /*  rrrrrggg gggbbbbb -> rrrrrRRR gggggg00 bbbbbBBB aaaaaaaa */
 593                         /*  little endian: aaaaaaaa bbbbbBBB gggggg00 rrrrrRRR */
 594 #ifdef LITTLE
 595                         /* swap endianness first */
 596                         data = s[0] | s[1] << 8;
 597                         s += 2;
 598                         *o++ = (data & 0xf800) >> 8 | (data & 0xe000) >> 13
 599                                 | (data & 0x7e0) << 5 | (data & 0x600) >> 1
 600                                 | (data & 0x1f) << 19 | (data & 0x1c) << 14
 601                                 | 0xff000000;
 602 #else
 603                         data = *s++;
 604                         *o++ = (data & 0xf800) << 16 | (data & 0xe000) << 11
 605                                 | (data & 0x7e0) << 13 | (data & 0x600) << 7
 606                                 | (data & 0x1f) << 11 | (data & 0x1c) << 6
 607                                 | 0xff;
 608 #endif
 609                 }
 610                 srow += bpl;
 611                 orow += rowstride;
 612         }
 613 }
 614
 615 /*
 616   convert 15 bits/pixel data
 617   no alpha
 618   data in lsb format
 619 */
 620 static void
 621 rgb555lsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 622 {
 623         int xx, yy;
 624         int width, height;
 625         int bpl;
 626
 627 #ifdef LITTLE
 628         register guint32 *s;    /* read 2 pixels at once */
 629 #else
 630         register guint8 *s;     /* read 2 pixels at once */
 631 #endif
 632         register guint16 *o;
 633         guint8 *srow = image->data, *orow = pixels;
 634
 635         width = image->width;
 636         height = image->height;
 637         bpl = image->bytes_per_line;
 638
 639         for (yy = 0; yy < height; yy++) {
 640 #ifdef LITTLE
 641                 s = (guint32 *) srow;
 642 #else
 643                 s = srow;
 644 #endif
 645                 o = (guint16 *) orow;
 646                 for (xx = 1; xx < width; xx += 2) {
 647                         register guint32 data;
 648 #ifdef LITTLE
 649                         data = *s++;
 650                         *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12
 651                                 | (data & 0x3e0) << 6 | (data & 0x380) << 1;
 652                         *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2
 653                                 | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20;
 654                         *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23
 655                                 | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10;
 656 #else
 657                         /* swap endianness first */
 658                         data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
 659                         s += 4;
 660                         *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4
 661                                 | (data & 0x3e0) >> 2 | (data & 0x380) >> 7;
 662                         *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6
 663                                 | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28;
 664                         *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15
 665                                 | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18;
 666 #endif
 667                 }
 668                 /* check for last remaining pixel */
 669                 if (width & 1) {
 670                         register guint16 data;
 671 #ifdef LITTLE
 672                         data = *((short *) s);
 673 #else
 674                         data = *((short *) s);
 675                         data = ((data >> 8) & 0xff) | ((data & 0xff) << 8);
 676 #endif
 677                         ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12;
 678                         ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7;
 679                         ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2;
 680                 }
 681                 srow += bpl;
 682                 orow += rowstride;
 683         }
 684 }
 685
 686 /*
 687   convert 15 bits/pixel data
 688   no alpha
 689   data in msb format
 690 */
 691 static void
 692 rgb555msb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 693 {
 694         int xx, yy;
 695         int width, height;
 696         int bpl;
 697
 698 #ifdef LITTLE
 699         register guint8 *s;     /* read 2 pixels at once */
 700 #else
 701         register guint32 *s;    /* read 2 pixels at once */
 702 #endif
 703         register guint16 *o;
 704         guint8 *srow = image->data, *orow = pixels;
 705
 706         width = image->width;
 707         height = image->height;
 708         bpl = image->bytes_per_line;
 709
 710         for (yy = 0; yy < height; yy++) {
 711                 s = srow;
 712                 o = (guint16 *) orow;
 713                 for (xx = 1; xx < width; xx += 2) {
 714                         register guint32 data;
 715 #ifdef LITTLE
 716                         /* swap endianness first */
 717                         data = s[0] | s[1] << 8 | s[2] << 16 | s[3] << 24;
 718                         s += 4;
 719                         *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12
 720                                 | (data & 0x3e0) << 6 | (data & 0x380) << 1;
 721                         *o++ = (data & 0x1f) << 3 | (data & 0x1c) >> 2
 722                                 | (data & 0x7c000000) >> 15 | (data & 0x70000000) >> 20;
 723                         *o++ = (data & 0x3e00000) >> 18 | (data & 0x3800000) >> 23
 724                                 | (data & 0x1f0000) >> 5 | (data & 0x1c0000) >> 10;
 725 #else
 726                         data = *s++;
 727                         *o++ = (data & 0x7c00) << 1 | (data & 0x7000) >> 4
 728                                 | (data & 0x3e0) >> 2 | (data & 0x380) >> 7;
 729                         *o++ = (data & 0x1f) << 11 | (data & 0x1c) << 6
 730                                 | (data & 0x7c000000) >> 23 | (data & 0x70000000) >> 28;
 731                         *o++ = (data & 0x3e00000) >> 10 | (data & 0x3800000) >> 15
 732                                 | (data & 0x1f0000) >> 13 | (data & 0x1c0000) >> 18;
 733 #endif
 734                 }
 735                 /* check for last remaining pixel */
 736                 if (width & 1) {
 737                         register guint16 data;
 738 #ifdef LITTLE
 739                         data = *((short *) s);
 740                         data = ((data >> 8) & 0xff) | ((data & 0xff) << 8);
 741 #else
 742                         data = *((short *) s);
 743 #endif
 744                         ((char *) o)[0] = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12;
 745                         ((char *) o)[1] = (data & 0x3e0) >> 2 | (data & 0x380) >> 7;
 746                         ((char *) o)[2] = (data & 0x1f) << 3 | (data & 0x1c) >> 2;
 747                 }
 748                 srow += bpl;
 749                 orow += rowstride;
 750         }
 751 }
 752
 753 /*
 754   convert 15 bits/pixel data
 755   with alpha
 756   data in lsb format
 757 */
 758 static void
 759 rgb555alsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 760 {
 761         int xx, yy;
 762         int width, height;
 763         int bpl;
 764
 765 #ifdef LITTLE
 766         register guint16 *s;    /* read 1 pixels at once */
 767 #else
 768         register guint8 *s;
 769 #endif
 770         register guint32 *o;
 771
 772         guint8 *srow = image->data, *orow = pixels;
 773
 774         width = image->width;
 775         height = image->height;
 776         bpl = image->bytes_per_line;
 777
 778         for (yy = 0; yy < height; yy++) {
 779 #ifdef LITTLE
 780                 s = (guint16 *) srow;
 781 #else
 782                 s = srow;
 783 #endif
 784                 o = (guint32 *) orow;
 785                 for (xx = 0; xx < width; xx++) {
 786                         register guint32 data;
 787                         /*  rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */
 788                         /*  little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */
 789 #ifdef LITTLE
 790                         data = *s++;
 791                         *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12
 792                                 | (data & 0x3e0) << 6 | (data & 0x380) << 1
 793                                 | (data & 0x1f) << 19 | (data & 0x1c) << 14
 794                                 | 0xff000000;
 795 #else
 796                         /* swap endianness first */
 797                         data = s[0] | s[1] << 8;
 798                         s += 2;
 799                         *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12
 800                                 | (data & 0x3e0) << 14 | (data & 0x380) << 9
 801                                 | (data & 0x1f) << 11 | (data & 0x1c) << 6
 802                                 | 0xff;
 803 #endif
 804                 }
 805                 srow += bpl;
 806                 orow += rowstride;
 807         }
 808 }
 809
 810 /*
 811   convert 15 bits/pixel data
 812   with alpha
 813   data in msb format
 814 */
 815 static void
 816 rgb555amsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 817 {
 818         int xx, yy;
 819         int width, height;
 820         int bpl;
 821
 822 #ifdef LITTLE
 823         register guint16 *s;    /* read 1 pixels at once */
 824 #else
 825         register guint8 *s;
 826 #endif
 827         register guint32 *o;
 828
 829         guint8 *srow = image->data, *orow = pixels;
 830
 831         width = image->width;
 832         height = image->height;
 833         bpl = image->bytes_per_line;
 834
 835         for (yy = 0; yy < height; yy++) {
 836 #ifdef LITTLE
 837                 s = (guint16 *) srow;
 838 #else
 839                 s = srow;
 840 #endif
 841                 o = (guint32 *) orow;
 842                 for (xx = 0; xx < width; xx++) {
 843                         register guint32 data;
 844                         /*  rrrrrggg gggbbbbb -> rrrrrRRR gggggGGG bbbbbBBB aaaaaaaa */
 845                         /*  little endian: aaaaaaaa bbbbbBBB gggggGGG rrrrrRRR */
 846 #ifdef LITTLE
 847                         /* swap endianness first */
 848                         data = s[0] | s[1] << 8;
 849                         s += 2;
 850                         *o++ = (data & 0x7c00) >> 7 | (data & 0x7000) >> 12
 851                                 | (data & 0x3e0) << 6 | (data & 0x380) << 1
 852                                 | (data & 0x1f) << 19 | (data & 0x1c) << 14
 853                                 | 0xff000000;
 854 #else
 855                         data = *s++;
 856                         *o++ = (data & 0x7c00) << 17 | (data & 0x7000) << 12
 857                                 | (data & 0x3e0) << 14 | (data & 0x380) << 9
 858                                 | (data & 0x1f) << 11 | (data & 0x1c) << 6
 859                                 | 0xff;
 860 #endif
 861                 }
 862                 srow += bpl;
 863                 orow += rowstride;
 864         }
 865 }
 866
 867
 868 static void
 869 rgb888alsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 870 {
 871         int xx, yy;
 872         int width, height;
 873         int bpl;
 874
 875         guint8 *s;      /* for byte order swapping */
 876         guint8 *o;
 877         guint8 *srow = image->data, *orow = pixels;
 878
 879         width = image->width;
 880         height = image->height;
 881         bpl = image->bytes_per_line;
 882
 883         /* lsb data */
 884         for (yy = 0; yy < height; yy++) {
 885                 s = srow;
 886                 o = orow;
 887                 for (xx = 0; xx < width; xx++) {
 888                         *o++ = s[2];
 889                         *o++ = s[1];
 890                         *o++ = s[0];
 891                         *o++ = 0xff;
 892                         s += 4;
 893                 }
 894                 srow += bpl;
 895                 orow += rowstride;
 896         }
 897 }
 898
 899 static void
 900 rgb888lsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 901 {
 902         int xx, yy;
 903         int width, height;
 904         int bpl;
 905
 906         guint8 *srow = image->data, *orow = pixels;
 907         guint8 *o, *s;
 908
 909         width = image->width;
 910         height = image->height;
 911         bpl = image->bytes_per_line;
 912
 913
 914         for (yy = 0; yy < height; yy++) {
 915                 s = srow;
 916                 o = orow;
 917                 for (xx = 0; xx < width; xx++) {
 918                         *o++ = s[2];
 919                         *o++ = s[1];
 920                         *o++ = s[0];
 921                         s += 4;
 922                 }
 923                 srow += bpl;
 924                 orow += rowstride;
 925         }
 926 }
 927
 928 static void
 929 rgb888amsb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 930 {
 931         int xx, yy;
 932         int width, height;
 933         int bpl;
 934
 935         guint8 *srow = image->data, *orow = pixels;
 936 #ifdef LITTLE
 937         guint32 *o;
 938         guint32 *s;
 939 #else
 940         guint8 *s;      /* for byte order swapping */
 941         guint8 *o;
 942 #endif
 943
 944
 945         width = image->width;
 946         height = image->height;
 947         bpl = image->bytes_per_line;
 948
 949         /* msb data */
 950         for (yy = 0; yy < height; yy++) {
 951 #ifdef LITTLE
 952                 s = (guint32 *) srow;
 953                 o = (guint32 *) orow;
 954 #else
 955                 s = srow;
 956                 o = orow;
 957 #endif
 958                 for (xx = 0; xx < width; xx++) {
 959 #ifdef LITTLE
 960                         *o++ = s[1];
 961                         *o++ = s[2];
 962                         *o++ = s[3];
 963                         *o++ = 0xff;
 964                         s += 4;
 965 #else
 966                         *o++ = (*s << 8) | 0xff; /* untested */
 967                         s++;
 968 #endif
 969                 }
 970                 srow += bpl;
 971                 orow += rowstride;
 972         }
 973 }
 974
 975 static void
 976 rgb888msb (XImage *image, guchar *pixels, int rowstride, xlib_colormap *colormap)
 977 {
 978         int xx, yy;
 979         int width, height;
 980         int bpl;
 981
 982         guint8 *srow = image->data, *orow = pixels;
 983         guint8 *s;
 984         guint8 *o;
 985
 986
 987         width = image->width;
 988         height = image->height;
 989         bpl = image->bytes_per_line;
 990
 991         for (yy = 0; yy < height; yy++) {
 992                 s = srow;
 993                 o = orow;
 994                 for (xx = 0; xx < width; xx++) {
 995                         *o++ = s[1];
 996                         *o++ = s[2];
 997                         *o++ = s[3];
 998                         s += 4;
 999                 }
1000                 srow += bpl;
1001                 orow += rowstride;
1002         }
1003 }
1004 static void
1005 visual_decompose_mask (gulong  mask,
1006                        gint   *shift,
1007                        gint   *prec)
1008 {
1009         *shift = 0;
1010         *prec = 0;
1011
1012         while (!(mask & 0x1)) {
1013                 (*shift)++;
1014                 mask >>= 1;
1015         }
1016
1017         while (mask & 0x1) {
1018                 (*prec)++;
1019                 mask >>= 1;
1020         }
1021 }
1022
1023
1024 /*
1025   This should work correctly with any display/any endianness, but will probably
1026   run quite slow
1027 */
1028 static void
1029 convert_real_slow (XImage *image, guchar *pixels, int rowstride, xlib_colormap *cmap, int alpha)
1030 {
1031         int xx, yy;
1032         int width, height;
1033         int bpl;
1034         guint8 *srow = image->data, *orow = pixels;
1035         guint8 *s;
1036         guint8 *o;
1037         guint32 pixel;
1038         Visual *v;
1039         guint8 component;
1040         int i;
1041         int red_shift, red_prec, green_shift, green_prec, blue_shift, blue_prec;
1042
1043         width = image->width;
1044         height = image->height;
1045         bpl = image->bytes_per_line;
1046         v = cmap->visual;
1047
1048         visual_decompose_mask (v->red_mask, &red_shift, &red_prec);
1049         visual_decompose_mask (v->green_mask, &green_shift, &green_prec);
1050         visual_decompose_mask (v->blue_mask, &blue_shift, &blue_prec);
1051
1052         for (yy = 0; yy < height; yy++) {
1053                 s = srow;
1054                 o = orow;
1055                 for (xx = 0; xx < width; xx++) {
1056                         pixel = XGetPixel (image, xx, yy);
1057                         switch (v->class) {
1058                                 /* I assume this is right for static & greyscale's too? */
1059                         case StaticGray:
1060                         case GrayScale:
1061                         case StaticColor:
1062                         case PseudoColor:
1063                                 *o++ = cmap->colors[pixel].red;
1064                                 *o++ = cmap->colors[pixel].green;
1065                                 *o++ = cmap->colors[pixel].blue;
1066                                 break;
1067                         case TrueColor:
1068                                 /* This is odd because it must sometimes shift left (otherwise
1069                                    I'd just shift >> (*_shift - 8 + *_prec + <0-7>). This logic
1070                                    should work for all bit sizes/shifts/etc. */
1071                                 component = 0;
1072                                 for (i = 24; i < 32; i += red_prec)
1073                                         component |= ((pixel & v->red_mask) << (32 - red_shift - red_prec)) >> i;
1074                                 *o++ = component;
1075                                 component = 0;
1076                                 for (i = 24; i < 32; i += green_prec)
1077                                         component |= ((pixel & v->green_mask) << (32 - green_shift - green_prec)) >> i;
1078                                 *o++ = component;
1079                                 component = 0;
1080                                 for (i = 24; i < 32; i += blue_prec)
1081                                         component |= ((pixel & v->blue_mask) << (32 - blue_shift - blue_prec)) >> i;
1082                                 *o++ = component;
1083                                 break;
1084                         case DirectColor:
1085                                 *o++ = cmap->colors[((pixel & v->red_mask) << (32 - red_shift - red_prec)) >> 24].red;
1086                                 *o++ = cmap->colors[((pixel & v->green_mask) << (32 - green_shift - green_prec)) >> 24].green;
1087                                 *o++ = cmap->colors[((pixel & v->blue_mask) << (32 - blue_shift - blue_prec)) >> 24].blue;
1088                                 break;
1089                         }
1090                         if (alpha)
1091                                 *o++ = 0xff;
1092                 }
1093                 srow += bpl;
1094                 orow += rowstride;
1095         }
1096 }
1097
1098 static xlib_colormap *
1099 xlib_get_colormap (Colormap id, Visual *visual, MagnifierData *mag_data)
1100 {
1101         int i;
1102         xlib_colormap *xc = g_new (xlib_colormap, 1);
1103
1104         xc->size = visual->map_entries;
1105         xc->colors = g_new (XColor, xc->size);
1106         xc->visual = visual;
1107         xc->colormap = id;
1108
1109         for (i = 0; i < xc->size; i++) {
1110                 xc->colors[i].pixel = i;
1111                 xc->colors[i].flags = DoRed | DoGreen | DoBlue;
1112         }
1113
1114         XQueryColors (mag_data->source_display, xc->colormap, xc->colors, xc->size);
1115
1116         return xc;
1117 }
1118
1119 typedef void (* cfunc) (XImage *image, guchar *pixels, int rowstride, xlib_colormap *cmap);
1120 static cfunc convert_map[] = {
1121         rgb1,rgb1,rgb1a,rgb1a,
1122         rgb8,rgb8,rgb8a,rgb8a,
1123         rgb555lsb,rgb555msb,rgb555alsb,rgb555amsb,
1124         rgb565lsb,rgb565msb,rgb565alsb,rgb565amsb,
1125         rgb888lsb,rgb888msb,rgb888alsb,rgb888amsb
1126 };
1127
1128 static void
1129 rgbconvert (XImage *image, guchar *pixels, int rowstride, int alpha, xlib_colormap *cmap,
1130             MagnifierData *mag_data)
1131 {
1132   int index = (image->byte_order == MSBFirst) | (alpha != 0) << 1;
1133   int bank=5;           /* default fallback converter */
1134   Visual *v = cmap->visual;
1135   if (mag_data->fast_rgb_convert)
1136     {
1137         switch (v->class) {
1138                                 /* I assume this is right for static & greyscale's too? */
1139         case StaticGray:
1140         case GrayScale:
1141         case StaticColor:
1142         case PseudoColor:
1143                 switch (image->bits_per_pixel) {
1144                 case 1:
1145                         bank = 0;
1146                         break;
1147                 case 8:
1148                         bank = 1;
1149                         break;
1150                 }
1151                 break;
1152         case TrueColor:
1153                 switch (image->depth) {
1154                 case 15:
1155                         if (v->red_mask == 0x7c00 && v->green_mask == 0x3e0 && v->blue_mask == 0x1f
1156                             && image->bits_per_pixel == 16)
1157                                 bank = 2;
1158                         break;
1159                 case 16:
1160                         if (v->red_mask == 0xf800 && v->green_mask == 0x7e0 && v->blue_mask == 0x1f
1161                             && image->bits_per_pixel == 16)
1162                                 bank = 3;
1163                         break;
1164                 case 24:
1165                 case 32:
1166                         if (v->red_mask == 0xff0000 && v->green_mask == 0xff00 && v->blue_mask == 0xff
1167                             && image->bits_per_pixel == 32)
1168                                 bank = 4;
1169                         break;
1170                 }
1171                 break;
1172         case DirectColor:
1173                 /* always use the slow version */
1174                 break;
1175         }
1176     }
1177
1178         if (bank==5) {
1179                 convert_real_slow(image, pixels, rowstride, cmap, alpha);
1180         } else {
1181                 index |= bank << 2;
1182                 (* convert_map[index]) (image, pixels, rowstride, cmap);
1183         }
1184 }
1185
1186 void get_root_image(Window src, GdkPixbuf *dest, int src_x, int src_y, MagnifierData *mag_data)  {
1187         XImage *image;
1188         int width = mag_data->mag_width/mag_data->factor_x;
1189         int height = mag_data->mag_height/mag_data->factor_y;
1190
1191         /* Get SpiImage in ZPixmap format (packed bits). */
1192         image = XGetImage (mag_data->source_display, src, src_x, src_y,
1193                            width, height, AllPlanes, ZPixmap);
1194         g_assert(image != NULL);
1195
1196         if(x_cmap == NULL){
1197             XWindowAttributes wa;
1198             XGetWindowAttributes (mag_data->source_display, src, &wa);
1199             x_cmap = xlib_get_colormap (wa.colormap, wa.visual, mag_data);
1200         }
1201         /* we offset into the image data based on the position we are retrieving from */
1202         rgbconvert (image, gdk_pixbuf_get_pixels(dest),
1203                     gdk_pixbuf_get_rowstride(dest),
1204                     gdk_pixbuf_get_has_alpha(dest),
1205                     x_cmap,
1206                     mag_data);
1207
1208         /* would like to use GDK routine, but since we don't have multi-head
1209            yet, we have to use X */
1210
1211         XDestroyImage (image);
1212 }
1213
1214