Icon Capture For Window Capturer

webrtc/modules/desktop_capture/window_capturer_x11.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 13 matching lines @@
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/x11/shared_x_display.h"
 #include "webrtc/modules/desktop_capture/x11/x_error_trap.h"
 #include "webrtc/modules/desktop_capture/x11/x_server_pixel_buffer.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
 namespace {
+const uint32_t kAlphaMask = 0xFF000000;
+const uint32_t kRedMask = 0x00FF0000;
+const uint32_t kGreenMask = 0x0000FF00;
+const uint32_t kBlueMask = 0x000000FF;
+
+const int kAlphaShift = 24;
+const int kRedShift = 16;
+const int kGreenShift = 8;
+const int kBlueShift = 0;
+
+uint32_t MultiplyAlpha(uint32_t raw_color_component, uint32_t alpha) {
+  uint32_t product = raw_color_component * alpha + 128;
+  return (product + (product >> 8)) >> 8;
+}
+
+// Convert a raw ARGB color pixel into a premultiplied ARGB color
+uint32_t PremultipliedColor(uint32_t raw_color) {
+  uint32_t alpha, red, green, blue;
+  alpha = (raw_color & kAlphaMask) >> kAlphaShift;
+  red = (raw_color & kRedMask) >> kRedShift;
+  green = (raw_color & kGreenMask) >> kGreenShift;
+  blue = (raw_color & kBlueMask) >> kBlueShift;
+
+  red = MultiplyAlpha(red, alpha);
+  green = MultiplyAlpha(green, alpha);
+  blue = MultiplyAlpha(blue, alpha);
+
+  return (alpha << kAlphaShift) | (red << kRedShift) | (green << kGreenShift) |
+         (blue << kBlueShift);
+}
 
 // Convenience wrapper for XGetWindowProperty() results.
 template <class PropertyType>
 class XWindowProperty {
  public:
   XWindowProperty(Display* display, Window window, Atom property) {
     const int kBitsPerByte = 8;
     Atom actual_type;
     int actual_format;
     unsigned long bytes_after;  // NOLINT: type required by XGetWindowProperty
@@ skipping 63 matching lines @@
   // that has WM_STATE property set to NormalState.
   // See http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.3.1 .
   ::Window GetApplicationWindow(::Window window);
 
   // Returns true if the |window| is a desktop element.
   bool IsDesktopElement(::Window window);
 
   // Returns window title for the specified X |window|.
   bool GetWindowTitle(::Window window, std::string* title);
 
+  std::unique_ptr<DesktopFrame> GetWindowIcon(::Window window);
+
   Callback* callback_ = nullptr;
 
   rtc::scoped_refptr<SharedXDisplay> x_display_;
 
   Atom wm_state_atom_;
   Atom window_type_atom_;
   Atom normal_window_type_atom_;
+  Atom icon_atom_;
   bool has_composite_extension_ = false;
 
   ::Window selected_window_ = 0;
   XServerPixelBuffer x_server_pixel_buffer_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(WindowCapturerLinux);
 };
 
 WindowCapturerLinux::WindowCapturerLinux(const DesktopCaptureOptions& options)
     : x_display_(options.x_display()) {
   // Create Atoms so we don't need to do it every time they are used.
   wm_state_atom_ = XInternAtom(display(), "WM_STATE", True);
   window_type_atom_ = XInternAtom(display(), "_NET_WM_WINDOW_TYPE", True);
   normal_window_type_atom_ = XInternAtom(
       display(), "_NET_WM_WINDOW_TYPE_NORMAL", True);
+  icon_atom_ = XInternAtom(display(), "_NET_WM_ICON", True);
 
   int event_base, error_base, major_version, minor_version;
   if (XCompositeQueryExtension(display(), &event_base, &error_base) &&
       XCompositeQueryVersion(display(), &major_version, &minor_version) &&
       // XCompositeNameWindowPixmap() requires version 0.2
       (major_version > 0 || minor_version >= 2)) {
     has_composite_extension_ = true;
   } else {
     LOG(LS_INFO) << "Xcomposite extension not available or too old.";
   }
 
   x_display_->AddEventHandler(ConfigureNotify, this);
 }
 
 WindowCapturerLinux::~WindowCapturerLinux() {
   x_display_->RemoveEventHandler(ConfigureNotify, this);
 }
 
 bool WindowCapturerLinux::GetWindowList(WindowList* windows) {
-  WindowList result;
-
+  windows->clear();
   XErrorTrap error_trap(display());
 
   int num_screens = XScreenCount(display());
   for (int screen = 0; screen < num_screens; ++screen) {
     ::Window root_window = XRootWindow(display(), screen);
     ::Window parent;
     ::Window *children;
     unsigned int num_children;
     int status = XQueryTree(display(), root_window, &root_window, &parent,
                             &children, &num_children);
     if (status == 0) {
       LOG(LS_ERROR) << "Failed to query for child windows for screen "
                     << screen;
       continue;
     }
 
     for (unsigned int i = 0; i < num_children; ++i) {
       // Iterate in reverse order to return windows from front to back.
       ::Window app_window =
           GetApplicationWindow(children[num_children - 1 - i]);
       if (app_window && !IsDesktopElement(app_window)) {
         Window w;
         w.id = app_window;
-        if (GetWindowTitle(app_window, &w.title))
-          result.push_back(w);
+        if (!GetWindowTitle(app_window, &w.title))
+          continue;
+        w.icon = GetWindowIcon(app_window);
+        windows->push_back(std::move(w));
       }
     }
 
     if (children)
       XFree(children);
   }
 
-  windows->swap(result);
-
   return true;
 }
 
 bool WindowCapturerLinux::SelectWindow(WindowId id) {
   if (!x_server_pixel_buffer_.Init(display(), id))
     return false;
 
   // Tell the X server to send us window resizing events.
   XSelectInput(display(), id, StructureNotifyMask);
 
@@ skipping 207 matching lines @@
       }
       if (list)
         XFreeStringList(list);
     }
     if (window_name.value)
       XFree(window_name.value);
   }
   return result;
 }
 
+std::unique_ptr<DesktopFrame> WindowCapturerLinux::GetWindowIcon(
+    ::Window window) {
+  XWindowProperty<uint32_t> icon_property(display(), window, icon_atom_);
+
+  long* data = (long*)icon_property.data();
+
+  uint32_t length = icon_property.size();
+  if (length == 0)
+    return nullptr;
+
+  long width, height;
+  int start = 0;
+  uint32_t i = 0;
+  while (i < length) {
+    if (i == 0 || data[i] * data[i + 1] > width * height) {
+      width = data[i];
+      height = data[i + 1];
+      start = i + 2;
+    }
+    i = i + 2 + data[i] * data[i + 1];
+  }
+
+  std::unique_ptr<DesktopFrame> frame(
+      new BasicDesktopFrame(DesktopSize(width, height)));
+
+  uint32_t* frame_data = (uint32_t*)frame->data();
+  int dest_int_stride = frame->stride() / sizeof(uint32_t);
+  for (int y = 0; y < height; ++y) {
+    for (int x = 0; x < width; ++x) {
+      frame_data[y * dest_int_stride + x] = PremultipliedColor(
+          static_cast<uint32_t>(data[start + y * width + x]));
+    }
+  }
+
+  frame->mutable_updated_region()->SetRect(
+      DesktopRect::MakeSize(frame->size()));
+
+  return frame;
+}
+
 }  // namespace
 
 // static
 WindowCapturer* WindowCapturer::Create(const DesktopCaptureOptions& options) {
   if (!options.x_display())
     return nullptr;
   return new WindowCapturerLinux(options);
 }
 
 }  // namespace webrtc