src/third_party/webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
  12
  13 #include <assert.h>
  14 #include <string.h>
  15 #include <sys/shm.h>
  16
  17 #include "webrtc/modules/desktop_capture/desktop_frame.h"
  18 #include "webrtc/modules/desktop_capture/x11/x_error_trap.h"
  19 #include "webrtc/system_wrappers/interface/logging.h"
  20
  21 namespace {
  22
  23 // Returns the number of bits |mask| has to be shifted left so its last
  24 // (most-significant) bit set becomes the most-significant bit of the word.
  25 // When |mask| is 0 the function returns 31.
  26 uint32_t MaskToShift(uint32_t mask) {
  27   int shift = 0;
  28   if ((mask & 0xffff0000u) == 0) {
  29     mask <<= 16;
  30     shift += 16;
  31   }
  32   if ((mask & 0xff000000u) == 0) {
  33     mask <<= 8;
  34     shift += 8;
  35   }
  36   if ((mask & 0xf0000000u) == 0) {
  37     mask <<= 4;
  38     shift += 4;
  39   }
  40   if ((mask & 0xc0000000u) == 0) {
  41     mask <<= 2;
  42     shift += 2;
  43   }
  44   if ((mask & 0x80000000u) == 0)
  45     shift += 1;
  46
  47   return shift;
  48 }
  49
  50 // Returns true if |image| is in RGB format.
  51 bool IsXImageRGBFormat(XImage* image) {
  52   return image->bits_per_pixel == 32 &&
  53       image->red_mask == 0xff0000 &&
  54       image->green_mask == 0xff00 &&
  55       image->blue_mask == 0xff;
  56 }
  57
  58 }  // namespace
  59
  60 namespace webrtc {
  61
  62 XServerPixelBuffer::XServerPixelBuffer()
  63     : display_(NULL), window_(0),
  64       x_image_(NULL),
  65       shm_segment_info_(NULL), shm_pixmap_(0), shm_gc_(NULL) {
  66 }
  67
  68 XServerPixelBuffer::~XServerPixelBuffer() {
  69   Release();
  70 }
  71
  72 void XServerPixelBuffer::Release() {
  73   if (x_image_) {
  74     XDestroyImage(x_image_);
  75     x_image_ = NULL;
  76   }
  77   if (shm_pixmap_) {
  78     XFreePixmap(display_, shm_pixmap_);
  79     shm_pixmap_ = 0;
  80   }
  81   if (shm_gc_) {
  82     XFreeGC(display_, shm_gc_);
  83     shm_gc_ = NULL;
  84   }
  85   if (shm_segment_info_) {
  86     if (shm_segment_info_->shmaddr != reinterpret_cast<char*>(-1))
  87       shmdt(shm_segment_info_->shmaddr);
  88     if (shm_segment_info_->shmid != -1)
  89       shmctl(shm_segment_info_->shmid, IPC_RMID, 0);
  90     delete shm_segment_info_;
  91     shm_segment_info_ = NULL;
  92   }
  93   window_ = 0;
  94 }
  95
  96 bool XServerPixelBuffer::Init(Display* display, Window window) {
  97   Release();
  98   display_ = display;
  99
 100   XWindowAttributes attributes;
 101   {
 102     XErrorTrap error_trap(display_);
 103     if (!XGetWindowAttributes(display_, window, &attributes) ||
 104         error_trap.GetLastErrorAndDisable() != 0) {
 105       return false;
 106     }
 107   }
 108
 109   window_size_ = DesktopSize(attributes.width, attributes.height);
 110   window_ = window;
 111   InitShm(attributes);
 112
 113   return true;
 114 }
 115
 116 void XServerPixelBuffer::InitShm(const XWindowAttributes& attributes) {
 117   Visual* default_visual = attributes.visual;
 118   int default_depth = attributes.depth;
 119
 120   int major, minor;
 121   Bool have_pixmaps;
 122   if (!XShmQueryVersion(display_, &major, &minor, &have_pixmaps)) {
 123     // Shared memory not supported. CaptureRect will use the XImage API instead.
 124     return;
 125   }
 126
 127   bool using_shm = false;
 128   shm_segment_info_ = new XShmSegmentInfo;
 129   shm_segment_info_->shmid = -1;
 130   shm_segment_info_->shmaddr = reinterpret_cast<char*>(-1);
 131   shm_segment_info_->readOnly = False;
 132   x_image_ = XShmCreateImage(display_, default_visual, default_depth, ZPixmap,
 133                              0, shm_segment_info_, window_size_.width(),
 134                              window_size_.height());
 135   if (x_image_) {
 136     shm_segment_info_->shmid = shmget(
 137         IPC_PRIVATE, x_image_->bytes_per_line * x_image_->height,
 138         IPC_CREAT | 0600);
 139     if (shm_segment_info_->shmid != -1) {
 140       shm_segment_info_->shmaddr = x_image_->data =
 141           reinterpret_cast<char*>(shmat(shm_segment_info_->shmid, 0, 0));
 142       if (x_image_->data != reinterpret_cast<char*>(-1)) {
 143         XErrorTrap error_trap(display_);
 144         using_shm = XShmAttach(display_, shm_segment_info_);
 145         XSync(display_, False);
 146         if (error_trap.GetLastErrorAndDisable() != 0)
 147           using_shm = false;
 148         if (using_shm) {
 149           LOG(LS_VERBOSE) << "Using X shared memory segment "
 150                           << shm_segment_info_->shmid;
 151         }
 152       }
 153     } else {
 154       LOG(LS_WARNING) << "Failed to get shared memory segment. "
 155                       "Performance may be degraded.";
 156     }
 157   }
 158
 159   if (!using_shm) {
 160     LOG(LS_WARNING) << "Not using shared memory. Performance may be degraded.";
 161     Release();
 162     return;
 163   }
 164
 165   if (have_pixmaps)
 166     have_pixmaps = InitPixmaps(default_depth);
 167
 168   shmctl(shm_segment_info_->shmid, IPC_RMID, 0);
 169   shm_segment_info_->shmid = -1;
 170
 171   LOG(LS_VERBOSE) << "Using X shared memory extension v"
 172                   << major << "." << minor
 173                   << " with" << (have_pixmaps ? "" : "out") << " pixmaps.";
 174 }
 175
 176 bool XServerPixelBuffer::InitPixmaps(int depth) {
 177   if (XShmPixmapFormat(display_) != ZPixmap)
 178     return false;
 179
 180   {
 181     XErrorTrap error_trap(display_);
 182     shm_pixmap_ = XShmCreatePixmap(display_, window_,
 183                                    shm_segment_info_->shmaddr,
 184                                    shm_segment_info_,
 185                                    window_size_.width(),
 186                                    window_size_.height(), depth);
 187     XSync(display_, False);
 188     if (error_trap.GetLastErrorAndDisable() != 0) {
 189       // |shm_pixmap_| is not not valid because the request was not processed
 190       // by the X Server, so zero it.
 191       shm_pixmap_ = 0;
 192       return false;
 193     }
 194   }
 195
 196   {
 197     XErrorTrap error_trap(display_);
 198     XGCValues shm_gc_values;
 199     shm_gc_values.subwindow_mode = IncludeInferiors;
 200     shm_gc_values.graphics_exposures = False;
 201     shm_gc_ = XCreateGC(display_, window_,
 202                         GCSubwindowMode | GCGraphicsExposures,
 203                         &shm_gc_values);
 204     XSync(display_, False);
 205     if (error_trap.GetLastErrorAndDisable() != 0) {
 206       XFreePixmap(display_, shm_pixmap_);
 207       shm_pixmap_ = 0;
 208       shm_gc_ = 0;  // See shm_pixmap_ comment above.
 209       return false;
 210     }
 211   }
 212
 213   return true;
 214 }
 215
 216 bool XServerPixelBuffer::IsWindowValid() const {
 217   XWindowAttributes attributes;
 218   {
 219     XErrorTrap error_trap(display_);
 220     if (!XGetWindowAttributes(display_, window_, &attributes) ||
 221         error_trap.GetLastErrorAndDisable() != 0) {
 222       return false;
 223     }
 224   }
 225   return true;
 226 }
 227
 228 void XServerPixelBuffer::Synchronize() {
 229   if (shm_segment_info_ && !shm_pixmap_) {
 230     // XShmGetImage can fail if the display is being reconfigured.
 231     XErrorTrap error_trap(display_);
 232     XShmGetImage(display_, window_, x_image_, 0, 0, AllPlanes);
 233   }
 234 }
 235
 236 void XServerPixelBuffer::CaptureRect(const DesktopRect& rect,
 237                                      DesktopFrame* frame) {
 238   assert(rect.right() <= window_size_.width());
 239   assert(rect.bottom() <= window_size_.height());
 240
 241   uint8_t* data;
 242
 243   if (shm_segment_info_) {
 244     if (shm_pixmap_) {
 245       XCopyArea(display_, window_, shm_pixmap_, shm_gc_,
 246                 rect.left(), rect.top(), rect.width(), rect.height(),
 247                 rect.left(), rect.top());
 248       XSync(display_, False);
 249     }
 250     data = reinterpret_cast<uint8_t*>(x_image_->data) +
 251         rect.top() * x_image_->bytes_per_line +
 252         rect.left() * x_image_->bits_per_pixel / 8;
 253   } else {
 254     if (x_image_)
 255       XDestroyImage(x_image_);
 256     x_image_ = XGetImage(display_, window_, rect.left(), rect.top(),
 257                          rect.width(), rect.height(), AllPlanes, ZPixmap);
 258     data = reinterpret_cast<uint8_t*>(x_image_->data);
 259   }
 260
 261   if (IsXImageRGBFormat(x_image_)) {
 262     FastBlit(data, rect, frame);
 263   } else {
 264     SlowBlit(data, rect, frame);
 265   }
 266 }
 267
 268 void XServerPixelBuffer::FastBlit(uint8_t* image,
 269                                   const DesktopRect& rect,
 270                                   DesktopFrame* frame) {
 271   uint8_t* src_pos = image;
 272   int src_stride = x_image_->bytes_per_line;
 273   int dst_x = rect.left(), dst_y = rect.top();
 274
 275   uint8_t* dst_pos = frame->data() + frame->stride() * dst_y;
 276   dst_pos += dst_x * DesktopFrame::kBytesPerPixel;
 277
 278   int height = rect.height();
 279   int row_bytes = rect.width() * DesktopFrame::kBytesPerPixel;
 280   for (int y = 0; y < height; ++y) {
 281     memcpy(dst_pos, src_pos, row_bytes);
 282     src_pos += src_stride;
 283     dst_pos += frame->stride();
 284   }
 285 }
 286
 287 void XServerPixelBuffer::SlowBlit(uint8_t* image,
 288                                   const DesktopRect& rect,
 289                                   DesktopFrame* frame) {
 290   int src_stride = x_image_->bytes_per_line;
 291   int dst_x = rect.left(), dst_y = rect.top();
 292   int width = rect.width(), height = rect.height();
 293
 294   uint32_t red_mask = x_image_->red_mask;
 295   uint32_t green_mask = x_image_->red_mask;
 296   uint32_t blue_mask = x_image_->blue_mask;
 297
 298   uint32_t red_shift = MaskToShift(red_mask);
 299   uint32_t green_shift = MaskToShift(green_mask);
 300   uint32_t blue_shift = MaskToShift(blue_mask);
 301
 302   int bits_per_pixel = x_image_->bits_per_pixel;
 303
 304   uint8_t* dst_pos = frame->data() + frame->stride() * dst_y;
 305   uint8_t* src_pos = image;
 306   dst_pos += dst_x * DesktopFrame::kBytesPerPixel;
 307   // TODO(hclam): Optimize, perhaps using MMX code or by converting to
 308   // YUV directly.
 309   // TODO(sergeyu): This code doesn't handle XImage byte order properly and
 310   // won't work with 24bpp images. Fix it.
 311   for (int y = 0; y < height; y++) {
 312     uint32_t* dst_pos_32 = reinterpret_cast<uint32_t*>(dst_pos);
 313     uint32_t* src_pos_32 = reinterpret_cast<uint32_t*>(src_pos);
 314     uint16_t* src_pos_16 = reinterpret_cast<uint16_t*>(src_pos);
 315     for (int x = 0; x < width; x++) {
 316       // Dereference through an appropriately-aligned pointer.
 317       uint32_t pixel;
 318       if (bits_per_pixel == 32) {
 319         pixel = src_pos_32[x];
 320       } else if (bits_per_pixel == 16) {
 321         pixel = src_pos_16[x];
 322       } else {
 323         pixel = src_pos[x];
 324       }
 325       uint32_t r = (pixel & red_mask) << red_shift;
 326       uint32_t g = (pixel & green_mask) << green_shift;
 327       uint32_t b = (pixel & blue_mask) << blue_shift;
 328       // Write as 32-bit RGB.
 329       dst_pos_32[x] = ((r >> 8) & 0xff0000) | ((g >> 16) & 0xff00) |
 330           ((b >> 24) & 0xff);
 331     }
 332     dst_pos += frame->stride();
 333     src_pos += src_stride;
 334   }
 335 }
 336
 337 }  // namespace webrtc