git.hungrycats.org Git - xscreensaver/blob - utils/visual.c

   1 /* xscreensaver, Copyright (c) 1993-2014 by Jamie Zawinski <jwz@jwz.org>
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10  */
  11
  12 /* This file contains some code for intelligently picking the best visual
  13    (where "best" is biased in the direction of either: high color counts;
  14    or: having writable color cells...)
  15  */
  16
  17 #include "utils.h"
  18 #include "resources.h"  /* for get_string_resource() */
  19 #include "visual.h"
  20
  21 #include <string.h>
  22 #include <X11/Xutil.h>
  23
  24 extern char *progname;
  25
  26
  27 #ifndef isupper
  28 # define isupper(c)  ((c) >= 'A' && (c) <= 'Z')
  29 #endif
  30 #ifndef _tolower
  31 # define _tolower(c)  ((c) - 'A' + 'a')
  32 #endif
  33
  34
  35 static Visual *pick_best_visual (Screen *, Bool, Bool);
  36 static Visual *pick_mono_visual (Screen *);
  37 static Visual *pick_best_visual_of_class (Screen *, int);
  38 static Visual *pick_best_gl_visual (Screen *);
  39
  40
  41 #define DEFAULT_VISUAL  -1
  42 #define BEST_VISUAL     -2
  43 #define MONO_VISUAL     -3
  44 #define GRAY_VISUAL     -4
  45 #define COLOR_VISUAL    -5
  46 #define GL_VISUAL       -6
  47 #define SPECIFIC_VISUAL -7
  48
  49 Visual *
  50 get_visual (Screen *screen, const char *string, Bool prefer_writable_cells,
  51             Bool verbose_p)
  52 {
  53   char *v = (string ? strdup(string) : 0);
  54   char c, *tmp;
  55   int vclass;
  56   unsigned long id;
  57   Visual *result = 0;
  58
  59   if (v)
  60     for (tmp = v; *tmp; tmp++)
  61       if (isupper (*tmp)) *tmp = _tolower (*tmp);
  62
  63   if (!v || !*v)                                  vclass = BEST_VISUAL;
  64   else if (!strcmp (v, "default"))                vclass = DEFAULT_VISUAL;
  65   else if (!strcmp (v, "best"))                   vclass = BEST_VISUAL;
  66   else if (!strcmp (v, "mono"))                   vclass = MONO_VISUAL;
  67   else if (!strcmp (v, "monochrome"))             vclass = MONO_VISUAL;
  68   else if (!strcmp (v, "gray"))                   vclass = GRAY_VISUAL;
  69   else if (!strcmp (v, "grey"))                   vclass = GRAY_VISUAL;
  70   else if (!strcmp (v, "color"))                  vclass = COLOR_VISUAL;
  71   else if (!strcmp (v, "gl"))                     vclass = GL_VISUAL;
  72   else if (!strcmp (v, "staticgray"))             vclass = StaticGray;
  73   else if (!strcmp (v, "staticcolor"))            vclass = StaticColor;
  74   else if (!strcmp (v, "truecolor"))              vclass = TrueColor;
  75   else if (!strcmp (v, "grayscale"))              vclass = GrayScale;
  76   else if (!strcmp (v, "greyscale"))              vclass = GrayScale;
  77   else if (!strcmp (v, "pseudocolor"))            vclass = PseudoColor;
  78   else if (!strcmp (v, "directcolor"))            vclass = DirectColor;
  79   else if (1 == sscanf (v, " %lu %c", &id, &c))   vclass = SPECIFIC_VISUAL;
  80   else if (1 == sscanf (v, " 0x%lx %c", &id, &c)) vclass = SPECIFIC_VISUAL;
  81   else
  82     {
  83       fprintf (stderr, "%s: unrecognized visual \"%s\".\n", progname, v);
  84       vclass = DEFAULT_VISUAL;
  85     }
  86
  87   if (vclass == DEFAULT_VISUAL)
  88     result = DefaultVisualOfScreen (screen);
  89   else if (vclass == BEST_VISUAL)
  90     result = pick_best_visual (screen, prefer_writable_cells, False);
  91   else if (vclass == MONO_VISUAL)
  92     {
  93       result = pick_mono_visual (screen);
  94       if (!result && verbose_p)
  95         fprintf (stderr, "%s: no monochrome visuals.\n", progname);
  96     }
  97   else if (vclass == GRAY_VISUAL)
  98     {
  99       if (prefer_writable_cells)
 100         result = pick_best_visual_of_class (screen, GrayScale);
 101       if (!result)
 102         result = pick_best_visual_of_class (screen, StaticGray);
 103       if (!result)
 104         result = pick_best_visual_of_class (screen, GrayScale);
 105       if (!result && verbose_p)
 106         fprintf (stderr, "%s: no GrayScale or StaticGray visuals.\n",
 107                  progname);
 108     }
 109   else if (vclass == COLOR_VISUAL)
 110     {
 111       int class;
 112       /* First see if the default visual will do. */
 113       result = DefaultVisualOfScreen (screen);
 114       class = visual_class(screen, result);
 115       if (class != TrueColor &&
 116           class != PseudoColor &&
 117           class != DirectColor &&
 118           class != StaticColor)
 119         result = 0;
 120       if (result && visual_depth(screen, result) <= 1)
 121         result = 0;
 122
 123       /* Else, find the best non-default color visual */
 124       if (!result)
 125         result = pick_best_visual (screen, prefer_writable_cells, True);
 126
 127       if (!result && verbose_p)
 128         fprintf (stderr, "%s: no color visuals.\n", progname);
 129     }
 130   else if (vclass == GL_VISUAL)
 131     {
 132       Visual *visual = pick_best_gl_visual (screen);
 133       if (visual)
 134         result = visual;
 135       else if (verbose_p)
 136         fprintf (stderr, "%s: no visual suitable for GL.\n", progname);
 137     }
 138   else if (vclass == SPECIFIC_VISUAL)
 139     {
 140       result = id_to_visual (screen, id);
 141       if (!result && verbose_p)
 142         fprintf (stderr, "%s: no visual with id 0x%x.\n", progname,
 143                  (unsigned int) id);
 144     }
 145   else
 146     {
 147       Visual *visual = pick_best_visual_of_class (screen, vclass);
 148       if (visual)
 149         result = visual;
 150       else if (verbose_p)
 151         fprintf (stderr, "%s: no visual of class %s.\n", progname, v);
 152     }
 153
 154   if (v) free (v);
 155   return result;
 156 }
 157
 158 Visual *
 159 get_visual_resource (Screen *screen, char *name, char *class,
 160                      Bool prefer_writable_cells)
 161 {
 162   char *string = get_string_resource (DisplayOfScreen (screen), name, class);
 163   Visual *v = get_visual (screen, string, prefer_writable_cells, True);
 164   if (string)
 165     free(string);
 166   if (v)
 167     return v;
 168   else
 169     return DefaultVisualOfScreen (screen);
 170 }
 171
 172
 173 static Visual *
 174 pick_best_visual (Screen *screen, Bool prefer_writable_cells, Bool color_only)
 175 {
 176   Visual *visual;
 177
 178   if (!prefer_writable_cells)
 179     {
 180       /* If we don't prefer writable cells, then the "best" visual is the one
 181          on which we can allocate the largest range and number of colors.
 182
 183          Therefore, a TrueColor visual which is at least 16 bits deep is best.
 184          (The assumption here being that a TrueColor of less than 16 bits is
 185          really just a PseudoColor visual with a pre-allocated color cube.)
 186
 187          The next best thing is a PseudoColor visual of any type.  After that
 188          come the non-colormappable visuals, and non-color visuals.
 189        */
 190       if ((visual = pick_best_visual_of_class (screen, TrueColor)) &&
 191           visual_depth (screen, visual) >= 16)
 192         return visual;
 193     }
 194
 195 #define TRY_CLASS(CLASS) \
 196   if ((visual = pick_best_visual_of_class (screen, CLASS)) && \
 197       (!color_only || visual_depth(screen, visual) > 1)) \
 198     return visual
 199   TRY_CLASS(PseudoColor);
 200   TRY_CLASS(TrueColor);
 201   TRY_CLASS(DirectColor);
 202   TRY_CLASS(StaticColor);
 203   if (!color_only)
 204     {
 205       TRY_CLASS(GrayScale);
 206       TRY_CLASS(StaticGray);
 207     }
 208 #undef TRY_CLASS
 209
 210   visual = DefaultVisualOfScreen (screen);
 211   if (!color_only || visual_depth(screen, visual) > 1)
 212     return visual;
 213   else
 214     return 0;
 215 }
 216
 217 static Visual *
 218 pick_mono_visual (Screen *screen)
 219 {
 220   Display *dpy = DisplayOfScreen (screen);
 221   XVisualInfo vi_in, *vi_out;
 222   int out_count;
 223
 224   vi_in.depth = 1;
 225   vi_in.screen = screen_number (screen);
 226   vi_out = XGetVisualInfo (dpy, (VisualDepthMask | VisualScreenMask),
 227                            &vi_in, &out_count);
 228   if (vi_out)
 229     {
 230       Visual *v = (out_count > 0 ? vi_out [0].visual : 0);
 231       if (v && vi_out[0].depth != 1)
 232         v = 0;
 233       XFree ((char *) vi_out);
 234       return v;
 235     }
 236   else
 237     return 0;
 238 }
 239
 240
 241 static Visual *
 242 pick_best_visual_of_class (Screen *screen, int visual_class)
 243 {
 244   /* The best visual of a class is the one which on which we can allocate
 245      the largest range and number of colors, which means the one with the
 246      greatest depth and number of cells.
 247
 248      (But actually, for XDaliClock, all visuals of the same class are
 249      probably equivalent - either we have writable cells or we don't.)
 250    */
 251   Display *dpy = DisplayOfScreen (screen);
 252   XVisualInfo vi_in, *vi_out;
 253   int out_count;
 254
 255   vi_in.class = visual_class;
 256   vi_in.screen = screen_number (screen);
 257   vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask),
 258                            &vi_in, &out_count);
 259   if (vi_out)
 260     {
 261       /* choose the 'best' one, if multiple */
 262       int i, best;
 263       Visual *visual;
 264 /*      for (i = 0, best = 0; i < out_count; i++) */
 265       for (i = out_count-1, best = i; i >= 0; i--) /* go backwards */
 266         /* It's better if it's deeper, or if it's the same depth with
 267            more cells (does that ever happen?  Well, it could...) */
 268         if ((vi_out [i].depth > vi_out [best].depth) ||
 269             ((vi_out [i].depth == vi_out [best].depth) &&
 270              (vi_out [i].colormap_size > vi_out [best].colormap_size)))
 271           best = i;
 272       visual = (best < out_count ? vi_out [best].visual : 0);
 273       XFree ((char *) vi_out);
 274       return visual;
 275     }
 276   else
 277     return 0;
 278 }
 279
 280 static Visual *
 281 pick_best_gl_visual (Screen *screen)
 282 {
 283   /* The best visual for GL is a TrueColor visual that is half as deep as
 284      the screen.  If such a thing doesn't exist, then TrueColor is best.
 285      Failing that, the deepest available color visual is best.
 286
 287      Compare this function to get_gl_visual() in visual-gl.c.
 288      This function tries to find the best GL visual using Xlib calls,
 289      whereas that function does the same thing using GLX calls.
 290    */
 291   Display *dpy = DisplayOfScreen (screen);
 292   XVisualInfo vi_in, *vi_out;
 293   int out_count;
 294   Visual *result = 0;
 295
 296   int ndepths = 0;
 297   int *depths = XListDepths (dpy, screen_number (screen), &ndepths);
 298   int screen_depth = depths[ndepths];
 299   XFree (depths);
 300
 301   vi_in.class = TrueColor;
 302   vi_in.screen = screen_number (screen);
 303   vi_in.depth = screen_depth / 2;
 304   vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask |
 305                                  VisualDepthMask),
 306                            &vi_in, &out_count);
 307   if (out_count > 0)
 308     result = vi_out[0].visual;
 309
 310   if (vi_out)
 311     XFree ((char *) vi_out);
 312
 313   if (!result && screen_depth > 24)
 314     {
 315       /* If it's a 32-deep screen and we didn't find a depth-16 visual,
 316          see if there's a depth-12 visual. */
 317       vi_in.class = TrueColor;
 318       vi_in.screen = screen_number (screen);
 319       vi_in.depth = 12;
 320       vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask |
 321                                      VisualDepthMask),
 322                                &vi_in, &out_count);
 323       if (out_count > 0)
 324         result = vi_out[0].visual;
 325     }
 326
 327   if (!result)
 328     /* No half-depth TrueColor?  Ok, try for any TrueColor (the deepest.) */
 329     result = pick_best_visual_of_class (screen, TrueColor);
 330
 331   if (!result)
 332     /* No TrueColor?  Ok, try for anything. */
 333     result = pick_best_visual (screen, False, False);
 334
 335   return result;
 336 }
 337
 338
 339 Visual *
 340 id_to_visual (Screen *screen, int id)
 341 {
 342   Display *dpy = DisplayOfScreen (screen);
 343   XVisualInfo vi_in, *vi_out;
 344   int out_count;
 345   vi_in.screen = screen_number (screen);
 346   vi_in.visualid = id;
 347   vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
 348                            &vi_in, &out_count);
 349   if (vi_out)
 350     {
 351       Visual *v = vi_out[0].visual;
 352       XFree ((char *) vi_out);
 353       return v;
 354     }
 355   return 0;
 356 }
 357
 358 int
 359 visual_depth (Screen *screen, Visual *visual)
 360 {
 361   Display *dpy = DisplayOfScreen (screen);
 362   XVisualInfo vi_in, *vi_out;
 363   int out_count, d;
 364   vi_in.screen = screen_number (screen);
 365   vi_in.visualid = XVisualIDFromVisual (visual);
 366   vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
 367                            &vi_in, &out_count);
 368   if (! vi_out) abort ();
 369   d = vi_out [0].depth;
 370   XFree ((char *) vi_out);
 371   return d;
 372 }
 373
 374
 375 #if 0
 376 /* You very probably don't want to be using this.
 377    Pixmap depth doesn't refer to the depths of pixmaps, but rather, to
 378    the depth of protocol-level on-the-wire pixmap data, that is, XImages.
 379    To get this info, you should be looking at XImage->bits_per_pixel
 380    instead.  (And allocating the data for your XImage structures by
 381    multiplying ximage->bytes_per_line by ximage->height.)
 382  */
 383 int
 384 visual_pixmap_depth (Screen *screen, Visual *visual)
 385 {
 386   Display *dpy = DisplayOfScreen (screen);
 387   int vdepth = visual_depth (screen, visual);
 388   int pdepth = vdepth;
 389   int i, pfvc = 0;
 390   XPixmapFormatValues *pfv = XListPixmapFormats (dpy, &pfvc);
 391
 392   /* Return the first matching depth in the pixmap formats.  If there are no
 393      matching pixmap formats (which shouldn't be able to happen at all) then
 394      return the visual depth instead. */
 395   for (i = 0; i < pfvc; i++)
 396     if (pfv[i].depth == vdepth)
 397       {
 398         pdepth = pfv[i].bits_per_pixel;
 399         break;
 400       }
 401   if (pfv)
 402     XFree (pfv);
 403   return pdepth;
 404 }
 405 #endif /* 0 */
 406
 407
 408 int
 409 visual_class (Screen *screen, Visual *visual)
 410 {
 411   Display *dpy = DisplayOfScreen (screen);
 412   XVisualInfo vi_in, *vi_out;
 413   int out_count, c;
 414   vi_in.screen = screen_number (screen);
 415   vi_in.visualid = XVisualIDFromVisual (visual);
 416   vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
 417                            &vi_in, &out_count);
 418   if (! vi_out) abort ();
 419   c = vi_out [0].class;
 420   XFree ((char *) vi_out);
 421   return c;
 422 }
 423
 424 Bool
 425 has_writable_cells (Screen *screen, Visual *visual)
 426 {
 427   switch (visual_class (screen, visual))
 428     {
 429     case GrayScale:     /* Mappable grays. */
 430     case PseudoColor:   /* Mappable colors. */
 431     case DirectColor:   /* Like TrueColor, but with three colormaps:
 432                            one each for red, green, and blue. */
 433       return True;
 434     case StaticGray:    /* Fixed grays. */
 435     case TrueColor:     /* Fixed colors. */
 436     case StaticColor:   /* Like PseudoColor with an unmodifiable colormap. */
 437       return False;
 438     default:
 439       abort();
 440       return False;
 441     }
 442 }
 443
 444 void
 445 describe_visual (FILE *f, Screen *screen, Visual *visual, Bool private_cmap_p)
 446 {
 447   char n[10];
 448   Display *dpy = DisplayOfScreen (screen);
 449   XVisualInfo vi_in, *vi_out;
 450   int out_count;
 451   vi_in.screen = screen_number (screen);
 452   vi_in.visualid = XVisualIDFromVisual (visual);
 453   vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
 454                            &vi_in, &out_count);
 455   if (! vi_out) abort ();
 456   if (private_cmap_p)
 457     sprintf(n, "%3d", vi_out->colormap_size);
 458   else
 459     strcpy(n, "default");
 460
 461   fprintf (f, "0x%02x (%s depth: %2d, cmap: %s)\n",
 462            (unsigned int) vi_out->visualid,
 463            (vi_out->class == StaticGray  ? "StaticGray, " :
 464             vi_out->class == StaticColor ? "StaticColor," :
 465             vi_out->class == TrueColor   ? "TrueColor,  " :
 466             vi_out->class == GrayScale   ? "GrayScale,  " :
 467             vi_out->class == PseudoColor ? "PseudoColor," :
 468             vi_out->class == DirectColor ? "DirectColor," :
 469                                            "UNKNOWN:    "),
 470            vi_out->depth, n);
 471   XFree ((char *) vi_out);
 472 }
 473
 474 int
 475 screen_number (Screen *screen)
 476 {
 477   Display *dpy = DisplayOfScreen (screen);
 478   int i;
 479   for (i = 0; i < ScreenCount (dpy); i++)
 480     if (ScreenOfDisplay (dpy, i) == screen)
 481       return i;
 482   abort ();
 483   return 0;
 484 }
 485
 486 int
 487 visual_cells (Screen *screen, Visual *visual)
 488 {
 489   Display *dpy = DisplayOfScreen (screen);
 490   XVisualInfo vi_in, *vi_out;
 491   int out_count, c;
 492   vi_in.screen = screen_number (screen);
 493   vi_in.visualid = XVisualIDFromVisual (visual);
 494   vi_out = XGetVisualInfo (dpy, VisualScreenMask|VisualIDMask,
 495                            &vi_in, &out_count);
 496   if (! vi_out) abort ();
 497   c = vi_out [0].colormap_size;
 498   XFree ((char *) vi_out);
 499   return c;
 500 }
 501
 502 Visual *
 503 find_similar_visual(Screen *screen, Visual *old_visual)
 504 {
 505   Display *dpy = DisplayOfScreen (screen);
 506   XVisualInfo vi_in, *vi_out;
 507   Visual *result = 0;
 508   int out_count;
 509
 510   vi_in.screen = screen_number (screen);
 511   vi_in.class  = visual_class (screen, old_visual);
 512   vi_in.depth  = visual_depth (screen, old_visual);
 513
 514   /* Look for a visual of the same class and depth.
 515    */
 516   vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask |
 517                                  VisualDepthMask),
 518                            &vi_in, &out_count);
 519   if (vi_out && out_count > 0)
 520     result = vi_out[0].visual;
 521   if (vi_out) XFree (vi_out);
 522   vi_out = 0;
 523
 524   /* Failing that, look for a visual of the same class.
 525    */
 526   if (!result)
 527     {
 528       vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualClassMask),
 529                                &vi_in, &out_count);
 530       if (vi_out && out_count > 0)
 531         result = vi_out[0].visual;
 532       if (vi_out) XFree (vi_out);
 533       vi_out = 0;
 534     }
 535
 536   /* Failing that, return the default visual. */
 537   if (!result)
 538     result = DefaultVisualOfScreen (screen);
 539
 540   return result;
 541 }
 542
 543
 544 int
 545 get_bits_per_pixel(Display *dpy, int depth)
 546 {
 547   unsigned i = 0;
 548   int count, result;
 549   XPixmapFormatValues *formats = XListPixmapFormats(dpy, &count);
 550
 551   /* XCreateImage calls _XGetBitsPerPixel to figure this out, but that function
 552      is private to Xlib.
 553
 554      For some reason, _XGetBitsPerPixel tries a hard-coded list of depths if
 555      it doesn't find a matching pixmap format, but I (Dave Odell) couldn't
 556      find any justification for this in the X11 spec. And the XFree86 CVS
 557      repository doesn't quite go back far enough to shed any light on what
 558      the deal is with that.
 559      http://cvsweb.xfree86.org/cvsweb/xc/lib/X11/ImUtil.c
 560
 561      The hard-coded list apparently was added between X11R5 and X11R6.
 562      See <ftp://ftp.x.org/pub/>.
 563    */
 564
 565   if (!formats) return 0;
 566
 567   for (;;)
 568     {
 569       if (i == (unsigned)count)
 570         {
 571           result = 0;
 572           break;
 573         }
 574
 575       if (formats[i].depth == depth)
 576         {
 577           result = formats[i].bits_per_pixel;
 578           break;
 579         }
 580
 581       ++i;
 582     }
 583
 584   XFree (formats);
 585   return result;
 586 }