diff options
author | mukai@chromium.org <mukai@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-01-08 00:04:36 +0000 |
---|---|---|
committer | mukai@chromium.org <mukai@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-01-08 00:04:36 +0000 |
commit | 101517a702f370bbe61e3420e93d93506e16c060 (patch) | |
tree | 078a1171a519097de3ddb4d55d94b770a51c43b1 | |
parent | e0eb7c401b51dc1761e5926c0e8e9c7872c6abdd (diff) | |
download | chromium_src-101517a702f370bbe61e3420e93d93506e16c060.zip chromium_src-101517a702f370bbe61e3420e93d93506e16c060.tar.gz chromium_src-101517a702f370bbe61e3420e93d93506e16c060.tar.bz2 |
Checks the possibility of overscans from EDID extension data.
BUG=141005
TEST=ui_unittests --gtest_filter='X11UtilTest.*' passed
Review URL: https://codereview.chromium.org/11725005
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@175421 0039d316-1c4b-4281-b951-d872f2087c98
-rw-r--r-- | ui/base/x/x11_util.cc | 217 | ||||
-rw-r--r-- | ui/base/x/x11_util.h | 23 | ||||
-rw-r--r-- | ui/base/x/x11_util_unittest.cc | 168 | ||||
-rw-r--r-- | ui/ui_unittests.gypi | 1 |
4 files changed, 354 insertions, 55 deletions
diff --git a/ui/base/x/x11_util.cc b/ui/base/x/x11_util.cc index 539c879..3e645c0 100644 --- a/ui/base/x/x11_util.cc +++ b/ui/base/x/x11_util.cc @@ -331,6 +331,53 @@ bool IsShapeAvailable() { } +// Get the EDID data from the |output| and stores to |prop|. |nitem| will store +// the number of characters |prop| will have. It doesn't take the ownership of +// |prop|, so caller must release it by XFree(). +// Returns true if EDID property is successfully obtained. Otherwise returns +// false and does not touch |prop| and |nitems|. +bool GetEDIDProperty(XID output, unsigned long* nitems, unsigned char** prop) { + if (!IsRandRAvailable()) + return false; + + static Atom edid_property = GetAtom(RR_PROPERTY_RANDR_EDID); + + Display* display = GetXDisplay(); + + bool has_edid_property = false; + int num_properties = 0; + Atom* properties = XRRListOutputProperties(display, output, &num_properties); + for (int i = 0; i < num_properties; ++i) { + if (properties[i] == edid_property) { + has_edid_property = true; + break; + } + } + XFree(properties); + if (!has_edid_property) + return false; + + Atom actual_type; + int actual_format; + unsigned long bytes_after; + XRRGetOutputProperty(display, + output, + edid_property, + 0, // offset + 128, // length + false, // _delete + false, // pending + AnyPropertyType, // req_type + &actual_type, + &actual_format, + nitems, + &bytes_after, + prop); + DCHECK_EQ(XA_INTEGER, actual_type); + DCHECK_EQ(8, actual_format); + return true; +} + } // namespace bool XDisplayExists() { @@ -1248,47 +1295,22 @@ bool GetOutputDeviceData(XID output, uint16* manufacturer_id, uint32* serial_number, std::string* human_readable_name) { - if (!IsRandRAvailable()) - return false; - - static Atom edid_property = GetAtom(RR_PROPERTY_RANDR_EDID); - - Display* display = GetXDisplay(); - - bool has_edid_property = false; - int num_properties = 0; - Atom* properties = XRRListOutputProperties(display, output, &num_properties); - for (int i = 0; i < num_properties; ++i) { - if (properties[i] == edid_property) { - has_edid_property = true; - break; - } - } - XFree(properties); - if (!has_edid_property) + unsigned long nitems = 0; + unsigned char *prop = NULL; + if (!GetEDIDProperty(output, &nitems, &prop)) return false; - Atom actual_type; - int actual_format; - unsigned long nitems; - unsigned long bytes_after; - unsigned char *prop; - XRRGetOutputProperty(display, - output, - edid_property, - 0, // offset - 128, // length - false, // _delete - false, // pending - AnyPropertyType, // req_type - &actual_type, - &actual_format, - &nitems, - &bytes_after, - &prop); - DCHECK_EQ(XA_INTEGER, actual_type); - DCHECK_EQ(8, actual_format); + bool result = ParseOutputDeviceData( + prop, nitems, manufacturer_id, serial_number, human_readable_name); + XFree(prop); + return result; +} +bool ParseOutputDeviceData(const unsigned char* prop, + unsigned long nitems, + uint16* manufacturer_id, + uint32* serial_number, + std::string* human_readable_name) { // See http://en.wikipedia.org/wiki/Extended_display_identification_data // for the details of EDID data format. We use the following data: // bytes 8-9: manufacturer EISA ID, in big-endian @@ -1306,37 +1328,34 @@ bool GetOutputDeviceData(XID output, const unsigned char kMonitorNameDescriptor = 0xfc; if (manufacturer_id) { - if (nitems < kManufacturerOffset + kManufacturerLength) { - XFree(prop); + if (nitems < kManufacturerOffset + kManufacturerLength) return false; - } - *manufacturer_id = *reinterpret_cast<uint16*>(prop + kManufacturerOffset); + + *manufacturer_id = + *reinterpret_cast<const uint16*>(prop + kManufacturerOffset); #if defined(ARCH_CPU_LITTLE_ENDIAN) *manufacturer_id = base::ByteSwap(*manufacturer_id); #endif } if (serial_number) { - if (nitems < kSerialNumberOffset + kSerialNumberLength) { - XFree(prop); + if (nitems < kSerialNumberOffset + kSerialNumberLength) return false; - } + *serial_number = base::ByteSwapToLE32( - *reinterpret_cast<uint32*>(prop + kSerialNumberOffset)); + *reinterpret_cast<const uint32*>(prop + kSerialNumberOffset)); } - if (!human_readable_name) { - XFree(prop); + if (!human_readable_name) return true; - } human_readable_name->clear(); for (unsigned int i = 0; i < kNumDescriptors; ++i) { - if (nitems < kDescriptorOffset + (i + 1) * kDescriptorLength) { + if (nitems < kDescriptorOffset + (i + 1) * kDescriptorLength) break; - } - unsigned char* desc_buf = prop + kDescriptorOffset + i * kDescriptorLength; + const unsigned char* desc_buf = + prop + kDescriptorOffset + i * kDescriptorLength; // If the descriptor contains the display name, it has the following // structure: // bytes 0-2, 4: \0 @@ -1348,15 +1367,13 @@ bool GetOutputDeviceData(XID output, desc_buf[4] == 0) { if (desc_buf[3] == kMonitorNameDescriptor) { std::string found_name( - reinterpret_cast<char*>(desc_buf + 5), kDescriptorLength - 5); + reinterpret_cast<const char*>(desc_buf + 5), kDescriptorLength - 5); TrimWhitespaceASCII(found_name, TRIM_TRAILING, human_readable_name); break; } } } - XFree(prop); - if (human_readable_name->empty()) return false; @@ -1372,6 +1389,96 @@ bool GetOutputDeviceData(XID output, return true; } +bool GetOutputOverscanFlag(XID output, bool* flag) { + unsigned long nitems = 0; + unsigned char *prop = NULL; + if (!GetEDIDProperty(output, &nitems, &prop)) + return false; + + bool found = ParseOutputOverscanFlag(prop, nitems, flag); + XFree(prop); + return found; +} + +bool ParseOutputOverscanFlag(const unsigned char* prop, + unsigned long nitems, + bool *flag) { + // See http://en.wikipedia.org/wiki/Extended_display_identification_data + // for the extension format of EDID. Also see EIA/CEA-861 spec for + // the format of the extensions and how video capability is encoded. + // - byte 0: tag. should be 02h. + // - byte 1: revision. only cares revision 3 (03h). + // - byte 4-: data block. + const unsigned int kExtensionBase = 128; + const unsigned int kExtensionSize = 128; + const unsigned int kNumExtensionsOffset = 126; + const unsigned int kDataBlockOffset = 4; + const unsigned char kCEAExtensionTag = '\x02'; + const unsigned char kExpectedExtensionRevision = '\x03'; + const unsigned char kExtendedTag = 7; + const unsigned char kExtendedVideoCapabilityTag = 0; + const unsigned int kPTOverscan = 4; + const unsigned int kITOverscan = 2; + const unsigned int kCEOverscan = 0; + + if (nitems <= kNumExtensionsOffset) + return false; + + unsigned char num_extensions = prop[kNumExtensionsOffset]; + + for (size_t i = 0; i < num_extensions; ++i) { + // Skip parsing the whole extension if size is not enough. + if (nitems <= kExtensionBase + (i + 1) * kExtensionSize) + break; + + const unsigned char* extension = prop + kExtensionBase + i * kExtensionSize; + unsigned char tag = extension[0]; + unsigned char revision = extension[1]; + if (tag != kCEAExtensionTag || revision != kExpectedExtensionRevision) + continue; + + unsigned char timing_descriptors_start = + std::min(extension[2], static_cast<unsigned char>(kExtensionSize)); + const unsigned char* data_block = extension + kDataBlockOffset; + while (data_block < extension + timing_descriptors_start) { + // A data block is encoded as: + // - byte 1 high 3 bits: tag. '07' for extended tags. + // - byte 1 remaining bits: the length of data block. + // - byte 2: the extended tag. '0' for video capability. + // - byte 3: the capability. + unsigned char tag = data_block[0] >> 5; + unsigned char payload_length = data_block[0] & 0x1f; + if (static_cast<unsigned long>(data_block + payload_length - prop) > + nitems) + break; + + if (tag != kExtendedTag && payload_length < 2) { + data_block += payload_length + 1; + continue; + } + + unsigned char extended_tag_code = data_block[1]; + if (extended_tag_code != kExtendedVideoCapabilityTag) { + data_block += payload_length; + continue; + } + + // The difference between preferred, IT, and CE video formats + // doesn't matter. Sets |flag| to true if any of these flags are true. + if ((data_block[2] & (1 << kPTOverscan)) || + (data_block[2] & (1 << kITOverscan)) || + (data_block[2] & (1 << kCEOverscan))) { + *flag = true; + } else { + *flag = false; + } + return true; + } + } + + return false; +} + std::vector<std::string> GetDisplayNames(const std::vector<XID>& output_ids) { std::vector<std::string> names; for (size_t i = 0; i < output_ids.size(); ++i) { diff --git a/ui/base/x/x11_util.h b/ui/base/x/x11_util.h index e7169a6..6cc0d64 100644 --- a/ui/base/x/x11_util.h +++ b/ui/base/x/x11_util.h @@ -276,6 +276,29 @@ UI_EXPORT bool GetOutputDeviceData(XID output, uint32* serial_number, std::string* human_readable_name); +// Gets the overscan flag from |output| and stores to |flag|. Returns true if +// the flag is found. Otherwise returns false and doesn't touch |flag|. The +// output will produce overscan if |flag| is set to true, but the output may +// still produce overscan even though it returns true and |flag| is set to +// false. +UI_EXPORT bool GetOutputOverscanFlag(XID output, bool* flag); + +// Parses |prop| as EDID data and stores extracted data into |manufacturer_id|, +// |serial_number|, and |human_readable_name| and returns true. NULL can be +// passed for unwanted output parameters. This is exported for +// x11_util_unittest.cc. +UI_EXPORT bool ParseOutputDeviceData(const unsigned char* prop, + unsigned long nitems, + uint16* manufacturer_id, + uint32* serial_number, + std::string* human_readable_name); + +// Parses |prop| as EDID data and stores the overscan flag to |flag|. Returns +// true if the flag is found. This is exported for x11_util_unittest.cc. +UI_EXPORT bool ParseOutputOverscanFlag(const unsigned char* prop, + unsigned long nitems, + bool* flag); + // Gets the names of the all displays physically connected to the system. UI_EXPORT std::vector<std::string> GetDisplayNames( const std::vector<XID>& output_id); diff --git a/ui/base/x/x11_util_unittest.cc b/ui/base/x/x11_util_unittest.cc new file mode 100644 index 0000000..802b9e9 --- /dev/null +++ b/ui/base/x/x11_util_unittest.cc @@ -0,0 +1,168 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "base/basictypes.h" +#include "base/memory/scoped_ptr.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "ui/base/x/x11_util.h" + +namespace ui { + +namespace { + +// Sample EDID data extracted from real devices. +const unsigned char kNormalDisplay[] = + "\x00\xff\xff\xff\xff\xff\xff\x00\x22\xf0\x6c\x28\x01\x01\x01\x01" + "\x02\x16\x01\x04\xb5\x40\x28\x78\xe2\x8d\x85\xad\x4f\x35\xb1\x25" + "\x0e\x50\x54\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" + "\x01\x01\x01\x01\x01\x01\xe2\x68\x00\xa0\xa0\x40\x2e\x60\x30\x20" + "\x36\x00\x81\x90\x21\x00\x00\x1a\xbc\x1b\x00\xa0\x50\x20\x17\x30" + "\x30\x20\x36\x00\x81\x90\x21\x00\x00\x1a\x00\x00\x00\xfc\x00\x48" + "\x50\x20\x5a\x52\x33\x30\x77\x0a\x20\x20\x20\x20\x00\x00\x00\xff" + "\x00\x43\x4e\x34\x32\x30\x32\x31\x33\x37\x51\x0a\x20\x20\x00\x71"; + +const unsigned char kInternalDisplay[] = + "\x00\xff\xff\xff\xff\xff\xff\x00\x4c\xa3\x42\x31\x00\x00\x00\x00" + "\x00\x15\x01\x03\x80\x1a\x10\x78\x0a\xd3\xe5\x95\x5c\x60\x90\x27" + "\x19\x50\x54\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01" + "\x01\x01\x01\x01\x01\x01\x9e\x1b\x00\xa0\x50\x20\x12\x30\x10\x30" + "\x13\x00\x05\xa3\x10\x00\x00\x19\x00\x00\x00\x0f\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x23\x87\x02\x64\x00\x00\x00\x00\xfe\x00\x53" + "\x41\x4d\x53\x55\x4e\x47\x0a\x20\x20\x20\x20\x20\x00\x00\x00\xfe" + "\x00\x31\x32\x31\x41\x54\x31\x31\x2d\x38\x30\x31\x0a\x20\x00\x45"; + +const unsigned char kOverscanDisplay[] = + "\x00\xff\xff\xff\xff\xff\xff\x00\x4c\x2d\xfe\x08\x00\x00\x00\x00" + "\x29\x15\x01\x03\x80\x10\x09\x78\x0a\xee\x91\xa3\x54\x4c\x99\x26" + "\x0f\x50\x54\xbd\xef\x80\x71\x4f\x81\xc0\x81\x00\x81\x80\x95\x00" + "\xa9\xc0\xb3\x00\x01\x01\x02\x3a\x80\x18\x71\x38\x2d\x40\x58\x2c" + "\x45\x00\xa0\x5a\x00\x00\x00\x1e\x66\x21\x56\xaa\x51\x00\x1e\x30" + "\x46\x8f\x33\x00\xa0\x5a\x00\x00\x00\x1e\x00\x00\x00\xfd\x00\x18" + "\x4b\x0f\x51\x17\x00\x0a\x20\x20\x20\x20\x20\x20\x00\x00\x00\xfc" + "\x00\x53\x41\x4d\x53\x55\x4e\x47\x0a\x20\x20\x20\x20\x20\x01\x1d" + "\x02\x03\x1f\xf1\x47\x90\x04\x05\x03\x20\x22\x07\x23\x09\x07\x07" + "\x83\x01\x00\x00\xe2\x00\x0f\x67\x03\x0c\x00\x20\x00\xb8\x2d\x01" + "\x1d\x80\x18\x71\x1c\x16\x20\x58\x2c\x25\x00\xa0\x5a\x00\x00\x00" + "\x9e\x01\x1d\x00\x72\x51\xd0\x1e\x20\x6e\x28\x55\x00\xa0\x5a\x00" + "\x00\x00\x1e\x8c\x0a\xd0\x8a\x20\xe0\x2d\x10\x10\x3e\x96\x00\xa0" + "\x5a\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6"; + +} + +TEST(X11UtilTest, ParseEDID) { + uint16 manufacturer_id = 0; + uint32 serial_number = 0; + std::string human_readable_name; + EXPECT_TRUE(ParseOutputDeviceData( + kNormalDisplay, arraysize(kNormalDisplay), + &manufacturer_id, &serial_number, &human_readable_name)); + EXPECT_EQ(0x22f0u, manufacturer_id); + EXPECT_EQ(0x01010101u, serial_number); + EXPECT_EQ("HP ZR30w", human_readable_name); + + manufacturer_id = 0; + serial_number = 0; + human_readable_name.clear(); + EXPECT_TRUE(ParseOutputDeviceData( + kInternalDisplay, arraysize(kInternalDisplay), + &manufacturer_id, &serial_number, NULL)); + EXPECT_EQ(0x4ca3u, manufacturer_id); + EXPECT_EQ(0x00000000u, serial_number); + EXPECT_EQ("", human_readable_name); + + // Internal display doesn't have name. + EXPECT_FALSE(ParseOutputDeviceData( + kInternalDisplay, arraysize(kInternalDisplay), + NULL, NULL, &human_readable_name)); + + manufacturer_id = 0; + serial_number = 0; + human_readable_name.clear(); + EXPECT_TRUE(ParseOutputDeviceData( + kOverscanDisplay, arraysize(kOverscanDisplay), + &manufacturer_id, &serial_number, &human_readable_name)); + EXPECT_EQ(0x4c2du, manufacturer_id); + EXPECT_EQ(0x00000000u, serial_number); + EXPECT_EQ("SAMSUNG", human_readable_name); +} + +TEST(X11UtilTest, ParseBrokenEDID) { + uint16 manufacturer_id = 0; + uint32 serial_number = 0; + std::string human_readable_name; + + // length == 0 + EXPECT_FALSE(ParseOutputDeviceData( + kNormalDisplay, 0, + &manufacturer_id, &serial_number, &human_readable_name)); + + // name is broken. Copying kNormalDisplay and substitute its name data by + // some control code. + std::string display_data( + reinterpret_cast<const char*>(kNormalDisplay), arraysize(kNormalDisplay)); + + // display's name data is embedded in byte 95-107 in this specific example. + // Fix here too when the contents of kNormalDisplay is altered. + display_data[97] = '\x1b'; + EXPECT_FALSE(ParseOutputDeviceData( + reinterpret_cast<const unsigned char*>(display_data.data()), + display_data.size(), + &manufacturer_id, &serial_number, &human_readable_name)); + + // If |human_readable_name| isn't specified, it skips parsing the name. + manufacturer_id = 0; + serial_number = 0; + EXPECT_TRUE(ParseOutputDeviceData( + reinterpret_cast<const unsigned char*>(display_data.data()), + display_data.size(), + &manufacturer_id, &serial_number, NULL)); + EXPECT_EQ(0x22f0u, manufacturer_id); + EXPECT_EQ(0x01010101u, serial_number); +} + +TEST(X11UtilTest, ParseOverscanFlag) { + bool flag = false; + EXPECT_FALSE(ParseOutputOverscanFlag( + kNormalDisplay, arraysize(kNormalDisplay), &flag)); + + flag = false; + EXPECT_FALSE(ParseOutputOverscanFlag( + kInternalDisplay, arraysize(kInternalDisplay), &flag)); + + flag = false; + EXPECT_TRUE(ParseOutputOverscanFlag( + kOverscanDisplay, arraysize(kOverscanDisplay), &flag)); + EXPECT_TRUE(flag); + + flag = false; + // Copy |kOverscanDisplay| and set flags to false in it. The overscan flags + // are embedded at byte 150 in this specific example. Fix here too when the + // contents of kOverscanDisplay is altered. + std::string display_data(reinterpret_cast<const char*>(kOverscanDisplay), + arraysize(kOverscanDisplay)); + display_data[150] = '\0'; + EXPECT_TRUE(ParseOutputOverscanFlag( + reinterpret_cast<const unsigned char*>(display_data.data()), + display_data.size(), &flag)); + EXPECT_FALSE(flag); +} + +TEST(X11UtilTest, ParseBrokenOverscanData) { + // Do not fill valid data here because it anyway fails to parse the data. + scoped_array<unsigned char> data(new unsigned char[126]); + bool flag = false; + EXPECT_FALSE(ParseOutputOverscanFlag(data.get(), 0, &flag)); + EXPECT_FALSE(ParseOutputOverscanFlag(data.get(), 126, &flag)); + + // extending data because ParseOutputOverscanFlag() will access the data. + data.reset(new unsigned char[150]); + // The number of CEA extensions is stored at byte 126. + data[126] = '\x01'; + EXPECT_FALSE(ParseOutputOverscanFlag(data.get(), 128, &flag)); + EXPECT_FALSE(ParseOutputOverscanFlag(data.get(), 150, &flag)); +} + +} diff --git a/ui/ui_unittests.gypi b/ui/ui_unittests.gypi index eb345f0..fdcbfc3 100644 --- a/ui/ui_unittests.gypi +++ b/ui/ui_unittests.gypi @@ -188,6 +188,7 @@ }], ['OS == "linux"', { 'sources': [ + 'base/x/x11_util_unittest.cc', 'gfx/platform_font_pango_unittest.cc', ], }], |