ui/gfx/x/x11_types.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/x/x11_types.h"
   6
   7 #include <X11/Xlib.h>
   8
   9 #include "base/command_line.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "ui/gfx/x/x11_switches.h"
  12
  13 namespace gfx {
  14
  15 XDisplay* GetXDisplay() {
  16   static XDisplay* display = NULL;
  17   if (!display)
  18     display = OpenNewXDisplay();
  19   return display;
  20 }
  21
  22 XDisplay* OpenNewXDisplay() {
  23 #if defined(OS_CHROMEOS)
  24   return XOpenDisplay(NULL);
  25 #else
  26   std::string display_str = base::CommandLine::ForCurrentProcess()->
  27                             GetSwitchValueASCII(switches::kX11Display);
  28   return XOpenDisplay(display_str.empty() ? NULL : display_str.c_str());
  29 #endif
  30 }
  31
  32 void PutARGBImage(XDisplay* display,
  33                   void* visual, int depth,
  34                   XID pixmap, void* pixmap_gc,
  35                   const uint8* data,
  36                   int width, int height) {
  37   PutARGBImage(display,
  38                visual, depth,
  39                pixmap, pixmap_gc,
  40                data, width, height,
  41                0, 0, // src_x, src_y
  42                0, 0, // dst_x, dst_y
  43                width, height);
  44 }
  45
  46 int BitsPerPixelForPixmapDepth(XDisplay* dpy, int depth) {
  47   int count;
  48   XPixmapFormatValues* formats = XListPixmapFormats(dpy, &count);
  49   if (!formats)
  50     return -1;
  51
  52   int bits_per_pixel = -1;
  53   for (int i = 0; i < count; ++i) {
  54     if (formats[i].depth == depth) {
  55       bits_per_pixel = formats[i].bits_per_pixel;
  56       break;
  57     }
  58   }
  59
  60   XFree(formats);
  61   return bits_per_pixel;
  62 }
  63
  64 void PutARGBImage(XDisplay* display,
  65                   void* visual, int depth,
  66                   XID pixmap, void* pixmap_gc,
  67                   const uint8* data,
  68                   int data_width, int data_height,
  69                   int src_x, int src_y,
  70                   int dst_x, int dst_y,
  71                   int copy_width, int copy_height) {
  72   // TODO(scherkus): potential performance impact... consider passing in as a
  73   // parameter.
  74   int pixmap_bpp = BitsPerPixelForPixmapDepth(display, depth);
  75
  76   XImage image;
  77   memset(&image, 0, sizeof(image));
  78
  79   image.width = data_width;
  80   image.height = data_height;
  81   image.format = ZPixmap;
  82   image.byte_order = LSBFirst;
  83   image.bitmap_unit = 8;
  84   image.bitmap_bit_order = LSBFirst;
  85   image.depth = depth;
  86   image.bits_per_pixel = pixmap_bpp;
  87   image.bytes_per_line = data_width * pixmap_bpp / 8;
  88
  89   if (pixmap_bpp == 32) {
  90     image.red_mask = 0xff0000;
  91     image.green_mask = 0xff00;
  92     image.blue_mask = 0xff;
  93
  94     // If the X server depth is already 32-bits and the color masks match,
  95     // then our job is easy.
  96     Visual* vis = static_cast<Visual*>(visual);
  97     if (image.red_mask == vis->red_mask &&
  98         image.green_mask == vis->green_mask &&
  99         image.blue_mask == vis->blue_mask) {
 100       image.data = const_cast<char*>(reinterpret_cast<const char*>(data));
 101       XPutImage(display, pixmap, static_cast<GC>(pixmap_gc), &image,
 102                 src_x, src_y, dst_x, dst_y,
 103                 copy_width, copy_height);
 104     } else {
 105       // Otherwise, we need to shuffle the colors around. Assume red and blue
 106       // need to be swapped.
 107       //
 108       // It's possible to use some fancy SSE tricks here, but since this is the
 109       // slow path anyway, we do it slowly.
 110
 111       uint8_t* bitmap32 =
 112           static_cast<uint8_t*>(malloc(4 * data_width * data_height));
 113       if (!bitmap32)
 114         return;
 115       uint8_t* const orig_bitmap32 = bitmap32;
 116       const uint32_t* bitmap_in = reinterpret_cast<const uint32_t*>(data);
 117       for (int y = 0; y < data_height; ++y) {
 118         for (int x = 0; x < data_width; ++x) {
 119           const uint32_t pixel = *(bitmap_in++);
 120           bitmap32[0] = (pixel >> 16) & 0xff;  // Red
 121           bitmap32[1] = (pixel >> 8) & 0xff;   // Green
 122           bitmap32[2] = pixel & 0xff;          // Blue
 123           bitmap32[3] = (pixel >> 24) & 0xff;  // Alpha
 124           bitmap32 += 4;
 125         }
 126       }
 127       image.data = reinterpret_cast<char*>(orig_bitmap32);
 128       XPutImage(display, pixmap, static_cast<GC>(pixmap_gc), &image,
 129                 src_x, src_y, dst_x, dst_y,
 130                 copy_width, copy_height);
 131       free(orig_bitmap32);
 132     }
 133   } else if (pixmap_bpp == 16) {
 134     // Some folks have VNC setups which still use 16-bit visuals and VNC
 135     // doesn't include Xrender.
 136
 137     uint16_t* bitmap16 =
 138         static_cast<uint16_t*>(malloc(2 * data_width * data_height));
 139     if (!bitmap16)
 140       return;
 141     uint16_t* const orig_bitmap16 = bitmap16;
 142     const uint32_t* bitmap_in = reinterpret_cast<const uint32_t*>(data);
 143     for (int y = 0; y < data_height; ++y) {
 144       for (int x = 0; x < data_width; ++x) {
 145         const uint32_t pixel = *(bitmap_in++);
 146         uint16_t out_pixel = ((pixel >> 8) & 0xf800) |
 147                              ((pixel >> 5) & 0x07e0) |
 148                              ((pixel >> 3) & 0x001f);
 149         *(bitmap16++) = out_pixel;
 150       }
 151     }
 152
 153     image.data = reinterpret_cast<char*>(orig_bitmap16);
 154     image.red_mask = 0xf800;
 155     image.green_mask = 0x07e0;
 156     image.blue_mask = 0x001f;
 157
 158     XPutImage(display, pixmap, static_cast<GC>(pixmap_gc), &image,
 159               src_x, src_y, dst_x, dst_y,
 160               copy_width, copy_height);
 161     free(orig_bitmap16);
 162   } else {
 163     LOG(FATAL) << "Sorry, we don't support your visual depth without "
 164                   "Xrender support (depth:" << depth
 165                << " bpp:" << pixmap_bpp << ")";
 166   }
 167 }
 168
 169 }  // namespace gfx
 170