| OLD | NEW |
|---|
| (Empty) |
| 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 "base/x11/edid_parser_x11.h" | |
| 6 | |
| 7 #include <X11/extensions/Xrandr.h> | |
| 8 #include <X11/Xatom.h> | |
| 9 #include <X11/Xlib.h> | |
| 10 | |
| 11 #include "base/hash.h" | |
| 12 #include "base/message_loop/message_loop.h" | |
| 13 #include "base/strings/string_util.h" | |
| 14 #include "base/sys_byteorder.h" | |
| 15 | |
| 16 namespace { | |
| 17 | |
| 18 // Returns 64-bit persistent ID for the specified manufacturer's ID and | |
| 19 // product_code_hash, and the index of the output it is connected to. | |
| 20 // |output_index| is used to distinguish the displays of the same type. For | |
| 21 // example, swapping two identical display between two outputs will not be | |
| 22 // treated as swap. The 'serial number' field in EDID isn't used here because | |
| 23 // it is not guaranteed to have unique number and it may have the same fixed | |
| 24 // value (like 0). | |
| 25 int64 GetID(uint16 manufacturer_id, | |
| 26 uint32 product_code_hash, | |
| 27 uint8 output_index) { | |
| 28 return ((static_cast<int64>(manufacturer_id) << 40) | | |
| 29 (static_cast<int64>(product_code_hash) << 8) | output_index); | |
| 30 } | |
| 31 | |
| 32 bool IsRandRAvailable() { | |
| 33 int randr_version_major = 0; | |
| 34 int randr_version_minor = 0; | |
| 35 static bool is_randr_available = XRRQueryVersion( | |
| 36 base::MessagePumpX11::GetDefaultXDisplay(), | |
| 37 &randr_version_major, &randr_version_minor); | |
| 38 return is_randr_available; | |
| 39 } | |
| 40 | |
| 41 } // namespace | |
| 42 | |
| 43 namespace base { | |
| 44 | |
| 45 bool GetEDIDProperty(XID output, unsigned long* nitems, unsigned char** prop) { | |
| 46 if (!IsRandRAvailable()) | |
| 47 return false; | |
| 48 | |
| 49 Display* display = base::MessagePumpX11::GetDefaultXDisplay(); | |
| 50 | |
| 51 static Atom edid_property = XInternAtom( | |
| 52 base::MessagePumpX11::GetDefaultXDisplay(), | |
| 53 RR_PROPERTY_RANDR_EDID, false); | |
| 54 | |
| 55 bool has_edid_property = false; | |
| 56 int num_properties = 0; | |
| 57 Atom* properties = XRRListOutputProperties(display, output, &num_properties); | |
| 58 for (int i = 0; i < num_properties; ++i) { | |
| 59 if (properties[i] == edid_property) { | |
| 60 has_edid_property = true; | |
| 61 break; | |
| 62 } | |
| 63 } | |
| 64 XFree(properties); | |
| 65 if (!has_edid_property) | |
| 66 return false; | |
| 67 | |
| 68 Atom actual_type; | |
| 69 int actual_format; | |
| 70 unsigned long bytes_after; | |
| 71 XRRGetOutputProperty(display, | |
| 72 output, | |
| 73 edid_property, | |
| 74 0, // offset | |
| 75 128, // length | |
| 76 false, // _delete | |
| 77 false, // pending | |
| 78 AnyPropertyType, // req_type | |
| 79 &actual_type, | |
| 80 &actual_format, | |
| 81 nitems, | |
| 82 &bytes_after, | |
| 83 prop); | |
| 84 DCHECK_EQ(XA_INTEGER, actual_type); | |
| 85 DCHECK_EQ(8, actual_format); | |
| 86 return true; | |
| 87 } | |
| 88 | |
| 89 bool GetDisplayId(XID output_id, size_t output_index, int64* display_id_out) { | |
| 90 unsigned long nitems = 0; | |
| 91 unsigned char* prop = NULL; | |
| 92 if (!GetEDIDProperty(output_id, &nitems, &prop)) | |
| 93 return false; | |
| 94 | |
| 95 bool result = | |
| 96 GetDisplayIdFromEDID(prop, nitems, output_index, display_id_out); | |
| 97 XFree(prop); | |
| 98 return result; | |
| 99 } | |
| 100 | |
| 101 bool GetDisplayIdFromEDID(const unsigned char* prop, | |
| 102 unsigned long nitems, | |
| 103 size_t output_index, | |
| 104 int64* display_id_out) { | |
| 105 uint16 manufacturer_id = 0; | |
| 106 std::string product_name; | |
| 107 | |
| 108 // ParseOutputDeviceData fails if it doesn't have product_name. | |
| 109 ParseOutputDeviceData(prop, nitems, &manufacturer_id, &product_name); | |
| 110 | |
| 111 // Generates product specific value from product_name instead of product code. | |
| 112 // See crbug.com/240341 | |
| 113 uint32 product_code_hash = product_name.empty() ? | |
| 114 0 : base::Hash(product_name); | |
| 115 if (manufacturer_id != 0) { | |
| 116 // An ID based on display's index will be assigned later if this call | |
| 117 // fails. | |
| 118 *display_id_out = GetID( | |
| 119 manufacturer_id, product_code_hash, output_index); | |
| 120 return true; | |
| 121 } | |
| 122 return false; | |
| 123 } | |
| 124 | |
| 125 bool ParseOutputDeviceData(const unsigned char* prop, | |
| 126 unsigned long nitems, | |
| 127 uint16* manufacturer_id, | |
| 128 std::string* human_readable_name) { | |
| 129 // See http://en.wikipedia.org/wiki/Extended_display_identification_data | |
| 130 // for the details of EDID data format. We use the following data: | |
| 131 // bytes 8-9: manufacturer EISA ID, in big-endian | |
| 132 // bytes 54-125: four descriptors (18-bytes each) which may contain | |
| 133 // the display name. | |
| 134 const unsigned int kManufacturerOffset = 8; | |
| 135 const unsigned int kManufacturerLength = 2; | |
| 136 const unsigned int kDescriptorOffset = 54; | |
| 137 const unsigned int kNumDescriptors = 4; | |
| 138 const unsigned int kDescriptorLength = 18; | |
| 139 // The specifier types. | |
| 140 const unsigned char kMonitorNameDescriptor = 0xfc; | |
| 141 | |
| 142 if (manufacturer_id) { | |
| 143 if (nitems < kManufacturerOffset + kManufacturerLength) { | |
| 144 LOG(ERROR) << "too short EDID data: manifacturer id"; | |
| 145 return false; | |
| 146 } | |
| 147 | |
| 148 *manufacturer_id = | |
| 149 *reinterpret_cast<const uint16*>(prop + kManufacturerOffset); | |
| 150 #if defined(ARCH_CPU_LITTLE_ENDIAN) | |
| 151 *manufacturer_id = base::ByteSwap(*manufacturer_id); | |
| 152 #endif | |
| 153 } | |
| 154 | |
| 155 if (!human_readable_name) | |
| 156 return true; | |
| 157 | |
| 158 human_readable_name->clear(); | |
| 159 for (unsigned int i = 0; i < kNumDescriptors; ++i) { | |
| 160 if (nitems < kDescriptorOffset + (i + 1) * kDescriptorLength) | |
| 161 break; | |
| 162 | |
| 163 const unsigned char* desc_buf = | |
| 164 prop + kDescriptorOffset + i * kDescriptorLength; | |
| 165 // If the descriptor contains the display name, it has the following | |
| 166 // structure: | |
| 167 // bytes 0-2, 4: \0 | |
| 168 // byte 3: descriptor type, defined above. | |
| 169 // bytes 5-17: text data, ending with \r, padding with spaces | |
| 170 // we should check bytes 0-2 and 4, since it may have other values in | |
| 171 // case that the descriptor contains other type of data. | |
| 172 if (desc_buf[0] == 0 && desc_buf[1] == 0 && desc_buf[2] == 0 && | |
| 173 desc_buf[4] == 0) { | |
| 174 if (desc_buf[3] == kMonitorNameDescriptor) { | |
| 175 std::string found_name( | |
| 176 reinterpret_cast<const char*>(desc_buf + 5), kDescriptorLength - 5); | |
| 177 TrimWhitespaceASCII(found_name, TRIM_TRAILING, human_readable_name); | |
| 178 break; | |
| 179 } | |
| 180 } | |
| 181 } | |
| 182 | |
| 183 // Verify if the |human_readable_name| consists of printable characters only. | |
| 184 for (size_t i = 0; i < human_readable_name->size(); ++i) { | |
| 185 char c = (*human_readable_name)[i]; | |
| 186 if (!isascii(c) || !isprint(c)) { | |
| 187 human_readable_name->clear(); | |
| 188 LOG(ERROR) << "invalid EDID: human unreadable char in name"; | |
| 189 return false; | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 return true; | |
| 194 } | |
| 195 | |
| 196 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 24365012:
Revert 225054 "linux_aura: Implement most of DesktopScreenX11." (Closed)
Base URL: svn://svn.chromium.org/chrome/