| // Copyright 2014 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| |
| #include "ui/display/util/edid_parser.h" |
| |
| #include <stddef.h> |
| |
| #include <algorithm> |
| #include <array> |
| #include <bitset> |
| #include <utility> |
| |
| #include "base/check.h" |
| #include "base/containers/span.h" |
| #include "base/hash/hash.h" |
| #include "base/hash/md5.h" |
| #include "base/logging.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/numerics/byte_conversions.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "third_party/abseil-cpp/absl/strings/ascii.h" |
| #include "third_party/skia/include/core/SkColorSpace.h" |
| #include "ui/display/util/display_util.h" |
| #include "ui/gfx/geometry/size.h" |
| |
| namespace display { |
| namespace { |
| |
| constexpr char kParseEdidFailureMetric[] = "Display.ParseEdidFailure"; |
| constexpr char kParseExternalDisplayEdidOptionalsMetric[] = |
| "Display.External.ParseEdidOptionals"; |
| constexpr char kBlockZeroSerialNumberTypeMetric[] = |
| "Display.External.BlockZeroSerialNumberType"; |
| constexpr char kNumOfSerialNumbersProvidedByExternalDisplay[] = |
| "Display.External.NumOfSerialNumbersProvided"; |
| constexpr uint8_t kMaxSerialNumberCount = 2; |
| constexpr uint8_t kDisplayIdExtensionTag = 0x70; |
| |
| // These values are persisted to logs. Entries should not be renumbered and |
| // numeric values should never be reused. |
| enum class ParseEdidFailure { |
| kNoError = 0, |
| kManufacturerId = 1, |
| kProductId = 2, |
| kYearOfManufacture = 3, |
| kBitsPerChannel = 4, |
| kGamma = 5, |
| kChromaticityCoordinates = 6, |
| kDisplayName = 7, |
| kExtensions = 8, |
| kSerialNumber = 9, |
| kWeekOfManufacture = 10, |
| kPhysicalSize = 11, |
| kMaxValue = kPhysicalSize, |
| }; |
| |
| // These values are persisted to logs. Entries should not be renumbered and |
| // numeric values should never be reused. This enum is used to track the |
| // availability (or lack thereof) of optional fields during EDID parsing. |
| enum class ParseEdidOptionals { |
| kAllAvailable = 0, |
| kBlockZeroSerialNumber = 1, |
| kDescriptorBlockSerialNumber = 2, |
| kWeekOfManufacture = 3, |
| kPhysicalSize = 4, |
| kMaxValue = kPhysicalSize, |
| }; |
| |
| // These values are persisted to logs. Entries should not be renumbered and |
| // numeric values should never be reused. This enum is used to track the |
| // serial number types that can be retrieved from an EDID's block zero. |
| enum class BlockZeroSerialNumberType { |
| kNormal = 0, |
| kRepeatingPattern = 1, |
| kNoSerialNumber = 2, |
| kMaxValue = kNoSerialNumber, |
| }; |
| |
| BlockZeroSerialNumberType GetSerialNumberType( |
| base::span<const uint8_t, 4u> serial_number) { |
| uint32_t sum = serial_number[0u]; |
| bool all_equal = true; |
| for (size_t i = 1u; i < serial_number.size(); ++i) { |
| sum += serial_number[i]; |
| if (serial_number[i - 1u] != serial_number[i]) { |
| all_equal = false; |
| } |
| } |
| |
| if (sum == 0u) { |
| return BlockZeroSerialNumberType::kNoSerialNumber; |
| } |
| |
| if (all_equal) { |
| return BlockZeroSerialNumberType::kRepeatingPattern; |
| } |
| |
| return BlockZeroSerialNumberType::kNormal; |
| } |
| } // namespace |
| |
| EdidParser::EdidParser(std::vector<uint8_t> edid_blob, bool is_external) |
| : edid_blob_(std::move(edid_blob)), |
| is_external_display_(is_external), |
| manufacturer_id_(0), |
| product_id_(0), |
| year_of_manufacture_(display::kInvalidYearOfManufacture), |
| gamma_(0.0), |
| bits_per_channel_(-1), |
| primaries_({0}), |
| audio_formats_(0) { |
| ParseEdid(edid_blob_); |
| } |
| |
| EdidParser::EdidParser(EdidParser&& other) = default; |
| EdidParser& EdidParser::operator=(EdidParser&& other) = default; |
| EdidParser::~EdidParser() = default; |
| |
| uint32_t EdidParser::GetProductCode() const { |
| return ((static_cast<uint32_t>(manufacturer_id_) << 16) | |
| (static_cast<uint32_t>(product_id_))); |
| } |
| |
| int64_t EdidParser::GetIndexBasedDisplayId(uint8_t output_index) const { |
| // Generates product specific value from product_name instead of product code. |
| // See https://crbug.com/240341 |
| const uint32_t product_code_hash = |
| display_name_.empty() ? 0 : base::Hash(display_name_); |
| // An ID based on display's index will be assigned later if this call fails. |
| return GenerateDisplayID(manufacturer_id_, product_code_hash, output_index); |
| } |
| |
| int64_t EdidParser::GetEdidBasedDisplayId() const { |
| const std::string string_to_hash = |
| base::NumberToString(manufacturer_id_) + |
| base::NumberToString(product_id_) + display_name_ + |
| base::NumberToString(week_of_manufacture()) + |
| base::NumberToString(year_of_manufacture_) + max_image_size().ToString() + |
| block_zero_serial_number_hash() + descriptor_block_serial_number_hash(); |
| return static_cast<int64_t>(base::PersistentHash(string_to_hash)); |
| } |
| |
| // static |
| void EdidParser::SplitProductCodeInManufacturerIdAndProductId( |
| int64_t product_code, |
| uint16_t* manufacturer_id, |
| uint16_t* product_id) { |
| DCHECK(manufacturer_id); |
| DCHECK(product_id); |
| // Undo GetProductCode() packing. |
| *product_id = product_code & 0xFFFF; |
| *manufacturer_id = (product_code >> 16) & 0xFFFF; |
| } |
| |
| // static |
| std::string EdidParser::ManufacturerIdToString(uint16_t manufacturer_id) { |
| // Constants are taken from "VESA Enhanced EDID Standard" Release A, Revision |
| // 2, Sep 2006, Sec 3.4.1 "ID Manufacturer Name: 2 Bytes". Essentially these |
| // are 3 5-bit ASCII characters packed in 2 bytes, where 1 means 'A', etc. |
| constexpr uint8_t kFiveBitAsciiMask = 0x1F; |
| constexpr char kFiveBitToAsciiOffset = 'A' - 1; |
| constexpr size_t kSecondLetterOffset = 5; |
| constexpr size_t kFirstLetterOffset = 10; |
| |
| char out[4] = {}; |
| out[2] = (manufacturer_id & kFiveBitAsciiMask) + kFiveBitToAsciiOffset; |
| out[1] = ((manufacturer_id >> kSecondLetterOffset) & kFiveBitAsciiMask) + |
| kFiveBitToAsciiOffset; |
| out[0] = ((manufacturer_id >> kFirstLetterOffset) & kFiveBitAsciiMask) + |
| kFiveBitToAsciiOffset; |
| return out; |
| } |
| |
| // static |
| std::string EdidParser::ProductIdToString(uint16_t product_id) { |
| // From "VESA Enhanced EDID Standard" Release A, Revision 2, Sep 2006, Sec |
| // 3.4.2 "ID Product Code: 2 Bytes": "The ID product code field, [...] |
| // contains a 2-byte manufacturer assigned product code. [...] The 2 byte |
| // number is stored in hex with the least significant byte listed first." |
| uint8_t lower_char = (product_id >> 8) & 0xFF; |
| uint8_t upper_char = product_id & 0xFF; |
| return base::StringPrintf("%02X%02X", upper_char, lower_char); |
| } |
| |
| bool EdidParser::TileCanScaleToFit() const { |
| return tile_can_scale_to_fit_; |
| } |
| |
| void EdidParser::ParseEdid(const std::vector<uint8_t>& edid) { |
| // 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 |
| // bytes 10-11: manufacturer product code, in little-endian |
| constexpr size_t kManufacturerOffset = 8; |
| constexpr size_t kManufacturerLength = 2; |
| constexpr size_t kProductIdOffset = 10; |
| constexpr size_t kProductIdLength = 2; |
| |
| if (edid.size() < kManufacturerOffset + kManufacturerLength) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kManufacturerId); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| // ICC filename is generated based on these ids. We always read this as big |
| // endian so that the file name matches bytes 8-11 as they appear in EDID. |
| manufacturer_id_ = base::U16FromBigEndian( |
| base::span(edid).subspan<kManufacturerOffset, kManufacturerLength>()); |
| |
| if (edid.size() < kProductIdOffset + kProductIdLength) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kProductId); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| // TODO: crbug.com/332745398 - The comment above says this data is in little |
| // endian, however there was a mistake in the past which led to us parsing |
| // this as big endian, and so we are now maintaining consistency with that. We |
| // cannot fix this without disturbing display support, as the product ID is |
| // used to produce display IDs and we need these to stay consistent. We'll |
| // have to keep parsing it incorrectly until we migrate to EDID-based display |
| // IDs. See also (googlers-only) http://b/193019614. |
| product_id_ = base::U16FromBigEndian( |
| base::span(edid).subspan<kProductIdOffset, kProductIdLength>()); |
| |
| // Bytes 12-15: display serial number, in little-endian (LSB). This field is |
| // optional and its absence is marked by having all bytes set to 0x00. |
| // Values do not represent ASCII characters. |
| constexpr size_t kSerialNumberOffset = 12; |
| constexpr size_t kSerialNumberLength = 4; |
| |
| if (edid.size() < kSerialNumberOffset + kSerialNumberLength) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kSerialNumber); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| |
| auto serial_number_bytes = |
| base::span(edid).subspan<kSerialNumberOffset, kSerialNumberLength>(); |
| |
| // Report the type of serial number encountered in block zero of external |
| // displays: empty (==0), repeating pattern (e.g. 01010101 or 0F0F0F0F), |
| // or normal. |
| if (is_external_display_) { |
| base::UmaHistogramEnumeration(kBlockZeroSerialNumberTypeMetric, |
| GetSerialNumberType(serial_number_bytes)); |
| } |
| |
| const uint32_t serial_number = base::U32FromLittleEndian(serial_number_bytes); |
| if (serial_number) { |
| block_zero_serial_number_hash_ = |
| base::MD5String(base::NumberToString(serial_number)); |
| } |
| |
| // Constants are taken from "VESA Enhanced EDID Standard" Release A, Revision |
| // 2, Sep 2006, Sec 3.4.4 "Week and Year of Manufacture or Model Year: 2 |
| // Bytes". |
| constexpr size_t kWeekOfManufactureOffset = 16; |
| constexpr uint32_t kValidWeekValueUpperBound = 0x36; |
| constexpr uint32_t kModelYearMarker = 0xFF; |
| |
| if (edid.size() < kWeekOfManufactureOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kWeekOfManufacture); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| { |
| const uint8_t byte_data = edid[kWeekOfManufactureOffset]; |
| // Store the value if it's within the range of 1-54 or equals to 0xFF. |
| if ((byte_data > 0x00 && byte_data <= kValidWeekValueUpperBound) || |
| byte_data == kModelYearMarker) { |
| week_of_manufacture_ = byte_data; |
| } |
| } |
| |
| constexpr size_t kYearOfManufactureOffset = 17; |
| constexpr uint32_t kValidYearValueLowerBound = 0x10; |
| constexpr int32_t kYearOffset = 1990; |
| |
| if (edid.size() < kYearOfManufactureOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kYearOfManufacture); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| { |
| const uint8_t byte_data = edid[kYearOfManufactureOffset]; |
| if (byte_data >= kValidYearValueLowerBound) { |
| year_of_manufacture_ = byte_data + kYearOffset; |
| } |
| } |
| |
| // Constants are taken from "VESA Enhanced EDID Standard" Release A, Revision |
| // 1, Feb 2000, Sec 3.6 "Basic Display Parameters and Features: 5 bytes" |
| constexpr static auto kBitsPerChannelTable = |
| std::to_array<int>({0, 6, 8, 10, 12, 14, 16, 0}); |
| |
| constexpr size_t kEDIDRevisionNumberOffset = 19; |
| constexpr uint8_t kEDIDRevision4Value = 4; |
| |
| constexpr size_t kVideoInputDefinitionOffset = 20; |
| constexpr uint8_t kDigitalInfoMask = 0x80; |
| constexpr uint8_t kColorBitDepthMask = 0x70; |
| constexpr uint8_t kColorBitDepthOffset = 4; |
| |
| if (edid.size() < kVideoInputDefinitionOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kBitsPerChannel); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| if (edid[kEDIDRevisionNumberOffset] >= kEDIDRevision4Value && |
| (edid[kVideoInputDefinitionOffset] & kDigitalInfoMask)) { |
| // EDID needs to be revision 4 at least, and kDigitalInfoMask be set for |
| // the Video Input Definition entry to describe a digital interface. |
| bits_per_channel_ = kBitsPerChannelTable[( |
| (edid[kVideoInputDefinitionOffset] & kColorBitDepthMask) >> |
| kColorBitDepthOffset)]; |
| } |
| |
| constexpr size_t kEDIDMaxHorizontalImageSizeOffset = 21; |
| constexpr size_t kEDIDMaxVerticalImageSizeOffset = 22; |
| |
| if (edid.size() < kEDIDMaxVerticalImageSizeOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kPhysicalSize); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| const gfx::Size max_image_size(edid[kEDIDMaxHorizontalImageSizeOffset], |
| edid[kEDIDMaxVerticalImageSizeOffset]); |
| if (!max_image_size.IsEmpty()) { |
| max_image_size_ = max_image_size; |
| } |
| |
| // Constants are taken from "VESA Enhanced EDID Standard" Release A, Revision |
| // 2, Sep 2006, Sec. 3.6.3 "Display Transfer Characteristics (GAMMA ): 1 Byte" |
| constexpr size_t kGammaOffset = 23; |
| constexpr double kGammaMultiplier = 100.0; |
| constexpr double kGammaBias = 100.0; |
| |
| if (edid.size() < kGammaOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kGamma); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| if (edid[kGammaOffset] != 0xFF) { |
| // Otherwise the byte at kGammaOffset is 0xFF, gamma is stored elsewhere. |
| gamma_ = (edid[kGammaOffset] + kGammaBias) / kGammaMultiplier; |
| } |
| |
| // Offsets, lengths, positions and masks are taken from [1] (or [2]). |
| // [1] http://en.wikipedia.org/wiki/Extended_display_identification_data |
| // [2] "VESA Enhanced EDID Standard " Release A, Revision 1, Feb 2000, Sec 3.7 |
| // "Phosphor or Filter Chromaticity: 10 bytes" |
| constexpr size_t kChromaticityOffset = 25; |
| constexpr unsigned int kChromaticityLength = 10; |
| |
| constexpr size_t kRedGreenLsbOffset = 25; |
| constexpr uint8_t kRedxLsbPosition = 6; |
| constexpr uint8_t kRedyLsbPosition = 4; |
| constexpr uint8_t kGreenxLsbPosition = 2; |
| constexpr uint8_t kGreenyLsbPosition = 0; |
| |
| constexpr size_t kBlueWhiteLsbOffset = 26; |
| constexpr uint8_t kBluexLsbPosition = 6; |
| constexpr uint8_t kBlueyLsbPosition = 4; |
| constexpr uint8_t kWhitexLsbPosition = 2; |
| constexpr uint8_t kWhiteyLsbPosition = 0; |
| |
| // All LSBits parts are 2 bits wide. |
| constexpr uint8_t kLsbMask = 0x3; |
| |
| constexpr size_t kRedxMsbOffset = 27; |
| constexpr size_t kRedyMsbOffset = 28; |
| constexpr size_t kGreenxMsbOffset = 29; |
| constexpr size_t kGreenyMsbOffset = 30; |
| constexpr size_t kBluexMsbOffset = 31; |
| constexpr size_t kBlueyMsbOffset = 32; |
| constexpr size_t kWhitexMsbOffset = 33; |
| constexpr size_t kWhiteyMsbOffset = 34; |
| |
| static_assert( |
| kChromaticityOffset + kChromaticityLength == kWhiteyMsbOffset + 1, |
| "EDID Parameter section length error"); |
| |
| if (edid.size() < kChromaticityOffset + kChromaticityLength) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kChromaticityCoordinates); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| |
| const uint8_t red_green_lsbs = edid[kRedGreenLsbOffset]; |
| const uint8_t blue_white_lsbs = edid[kBlueWhiteLsbOffset]; |
| |
| // Recompose the 10b values by appropriately mixing the 8 MSBs and the 2 LSBs, |
| // then rescale to 1024; |
| primaries_.fRX = ((edid[kRedxMsbOffset] << 2) + |
| ((red_green_lsbs >> kRedxLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fRY = ((edid[kRedyMsbOffset] << 2) + |
| ((red_green_lsbs >> kRedyLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fGX = ((edid[kGreenxMsbOffset] << 2) + |
| ((red_green_lsbs >> kGreenxLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fGY = ((edid[kGreenyMsbOffset] << 2) + |
| ((red_green_lsbs >> kGreenyLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fBX = ((edid[kBluexMsbOffset] << 2) + |
| ((blue_white_lsbs >> kBluexLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fBY = ((edid[kBlueyMsbOffset] << 2) + |
| ((blue_white_lsbs >> kBlueyLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fWX = ((edid[kWhitexMsbOffset] << 2) + |
| ((blue_white_lsbs >> kWhitexLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| primaries_.fWY = ((edid[kWhiteyMsbOffset] << 2) + |
| ((blue_white_lsbs >> kWhiteyLsbPosition) & kLsbMask)) / |
| 1024.0f; |
| // TODO(mcasas): Up to two additional White Point coordinates can be provided |
| // in a Display Descriptor. Read them if we are not satisfied with |fWX| or |
| // |fWy|. https://crbug.com/771345. |
| |
| // See http://en.wikipedia.org/wiki/Extended_display_identification_data |
| // for the details of EDID data format. We use the following data: |
| // bytes 54-125: four descriptors (18-bytes each) which may contain |
| // the display name. |
| constexpr size_t kDescriptorOffset = 54; |
| constexpr size_t kNumDescriptors = 4; |
| constexpr size_t kDescriptorLength = 18; |
| // The specifier types. |
| constexpr uint8_t kMonitorNameDescriptor = 0xfc; |
| constexpr uint8_t kDisplayRangeLimitsDescriptor = 0xfd; |
| constexpr uint8_t kMonitorSerialNumberDescriptor = 0xff; |
| |
| display_name_.clear(); |
| for (size_t i = 0; i < kNumDescriptors; ++i) { |
| if (edid.size() < kDescriptorOffset + (i + 1) * kDescriptorLength) { |
| break; |
| } |
| |
| size_t offset = kDescriptorOffset + i * kDescriptorLength; |
| |
| // Detailed Timing Descriptor: |
| if (edid[offset] != 0 && edid[offset + 1] != 0) { |
| constexpr int kMaxResolution = 10080; // 8k display. |
| |
| // EDID may contain multiple DTD. Use the first one, that contains the |
| // highest resolution. |
| if (active_pixel_size_.IsEmpty()) { |
| constexpr size_t kHorizontalPixelLsbOffset = 2; |
| constexpr size_t kHorizontalPixelMsbOffset = 4; |
| constexpr size_t kVerticalPixelLsbOffset = 5; |
| constexpr size_t kVerticalPixelMsbOffset = 7; |
| |
| const uint8_t h_lsb = edid[offset + kHorizontalPixelLsbOffset]; |
| const uint8_t h_msb = edid[offset + kHorizontalPixelMsbOffset]; |
| int h_pixel = std::min(h_lsb + ((h_msb & 0xF0) << 4), kMaxResolution); |
| |
| const uint8_t v_lsb = edid[offset + kVerticalPixelLsbOffset]; |
| const uint8_t v_msb = edid[offset + kVerticalPixelMsbOffset]; |
| int v_pixel = std::min(v_lsb + ((v_msb & 0xF0) << 4), kMaxResolution); |
| |
| active_pixel_size_.SetSize(h_pixel, v_pixel); |
| } |
| continue; |
| } |
| |
| // EDID Other Monitor Descriptors: |
| // If the descriptor contains the display name, it has the following |
| // structure: |
| // bytes 0-2, 4: \0 |
| // byte 3: 0xfc |
| // bytes 5-17: text data, ending with \r, padding with spaces |
| // we should check bytes 0-2 and 4, since it may have other values in |
| // case that the descriptor contains other type of data. |
| if (edid[offset] == 0 && edid[offset + 1] == 0 && edid[offset + 2] == 0 && |
| edid[offset + 3] == kMonitorNameDescriptor && edid[offset + 4] == 0) { |
| std::string name(reinterpret_cast<const char*>(&edid[offset + 5]), |
| kDescriptorLength - 5); |
| base::TrimWhitespaceASCII(name, base::TRIM_TRAILING, &display_name_); |
| continue; |
| } |
| |
| // If the descriptor contains the display's range limits, it has the |
| // following structure: |
| // bytes 0-2: \0 |
| // byte 3: 0xfd |
| // byte 4: Offsets for display range limits |
| // bytes 5-17: Display range limits and timing information |
| if (edid[offset] == 0 && edid[offset + 1] == 0 && edid[offset + 2] == 0 && |
| edid[offset + 3] == kDisplayRangeLimitsDescriptor) { |
| // byte 4: Offsets for display range limits |
| const uint8_t rateOffset = edid[offset + 4]; |
| // bits 7-4: Reserved \0 |
| if (rateOffset & 0xf0) { |
| continue; |
| } |
| // bit 3: Horizontal max rate offset (not used) |
| // bit 2: Horizontal min rate offset (not used) |
| // bit 1: Vertical max rate offset (not used) |
| // bit 0: Vertical min rate offset |
| const uint8_t verticalMinRateOffset = rateOffset & (1 << 0) ? 255 : 0; |
| |
| // bytes 5-8: Rate limits |
| // Each byte must be within [1, 255]. |
| if (edid[offset + 5] == 0 || edid[offset + 6] == 0 || |
| edid[offset + 7] == 0 || edid[offset + 8] == 0) { |
| continue; |
| } |
| // byte 5: Min vertical rate in Hz |
| vsync_rate_min_ = edid[offset + 5] + verticalMinRateOffset; |
| // byte 6: Max vertical rate in Hz (not used) |
| // byte 7: Min horizontal rate in kHz (not used) |
| // byte 8: Max horizontal rate in kHz (not used) |
| |
| // byte 9: Maximum pixel clock rate (not used) |
| // byte 10: Extended timing information type (not used) |
| // bytes 11-17: Video timing parameters (not used) |
| |
| continue; |
| } |
| |
| // If the descriptor contains the display's product serial number, it has |
| // the following structure: |
| // bytes 0-2, 4: \0 |
| // byte 3: 0xff |
| // bytes 5-17: text data, ending with \r, padding with spaces |
| // we should check bytes 0-2 and 4, since it may have other values in |
| // case that the descriptor contains other type of data. |
| if (edid[offset] == 0 && edid[offset + 1] == 0 && edid[offset + 2] == 0 && |
| edid[offset + 3] == kMonitorSerialNumberDescriptor && |
| edid[offset + 4] == 0) { |
| std::string serial_number_str( |
| reinterpret_cast<const char*>(&edid[offset + 5]), |
| kDescriptorLength - 5); |
| base::TrimWhitespaceASCII(serial_number_str, base::TRIM_TRAILING, |
| &serial_number_str); |
| if (!serial_number_str.empty()) { |
| descriptor_block_serial_number_hash_ = |
| base::MD5String(serial_number_str); |
| } |
| continue; |
| } |
| } |
| |
| // Verify if the |display_name_| consists of printable characters only. |
| // Replace unprintable chars with white space. |
| std::replace_if( |
| display_name_.begin(), display_name_.end(), |
| [](unsigned char c) { |
| return !absl::ascii_isascii(c) || !absl::ascii_isprint(c); |
| }, |
| ' '); |
| |
| // 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. |
| constexpr size_t kExtensionBaseOffset = 128; |
| constexpr size_t kExtensionSize = 128; |
| constexpr size_t kNumExtensionsOffset = 126; |
| constexpr size_t kDataBlockOffset = 4; |
| constexpr uint8_t kCEAExtensionTag = '\x02'; |
| constexpr uint8_t kExpectedExtensionRevision = '\x03'; |
| constexpr uint8_t kAudioTag = 1; |
| constexpr uint8_t kExtendedTag = 7; |
| constexpr uint8_t kExtendedVideoCapabilityTag = 0; |
| constexpr uint8_t kPTOverscanFlagPosition = 4; |
| constexpr uint8_t kITOverscanFlagPosition = 2; |
| constexpr uint8_t kCEOverscanFlagPosition = 0; |
| // See CTA-861-F, particularly Table 56 "Colorimetry Data Block". |
| constexpr uint8_t kColorimetryDataBlockCapabilityTag = 0x05; |
| constexpr auto kPrimaryMatrixIDMap = std::to_array< |
| std::pair<gfx::ColorSpace::PrimaryID, gfx::ColorSpace::MatrixID>>({ |
| // xvYCC601. Standard Definition Colorimetry based on IEC 61966-2-4. |
| {gfx::ColorSpace::PrimaryID::SMPTE170M, |
| gfx::ColorSpace::MatrixID::SMPTE170M}, |
| // xvYCC709. High Definition Colorimetry based on IEC 61966-2-4. |
| {gfx::ColorSpace::PrimaryID::BT709, gfx::ColorSpace::MatrixID::BT709}, |
| // sYCC601. Colorimetry based on IEC 61966-2-1/Amendment 1. |
| {gfx::ColorSpace::PrimaryID::SMPTE170M, |
| gfx::ColorSpace::MatrixID::SMPTE170M}, |
| // opYCC601. Colorimetry based on IEC 61966-2-5, Annex A. |
| {gfx::ColorSpace::PrimaryID::SMPTE170M, |
| gfx::ColorSpace::MatrixID::SMPTE170M}, |
| // opRGB, Colorimetry based on IEC 61966-2-5. |
| {gfx::ColorSpace::PrimaryID::SMPTE170M, gfx::ColorSpace::MatrixID::RGB}, |
| // BT2020YCC. Colorimetry based on ITU-R BT.2020 Y’C’BC’R. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // BT2020YCC. Colorimetry based on ITU-R BT.2020 Y’C’BC’R. |
| {gfx::ColorSpace::PrimaryID::BT2020, |
| gfx::ColorSpace::MatrixID::BT2020_NCL}, |
| // BT2020RGB. Colorimetry based on ITU-R BT.2020 R’G’B’. |
| {gfx::ColorSpace::PrimaryID::BT2020, gfx::ColorSpace::MatrixID::RGB}, |
| // MD0. Metadata bit. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // MD1. Metadata bit. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // MD2. Metadata bit. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // MD3. Metadata bit. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // F44=0. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // F45=0. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // F46=0. |
| {gfx::ColorSpace::PrimaryID::INVALID, gfx::ColorSpace::MatrixID::INVALID}, |
| // DCI-P3. Colorimetry based on DCI-P3. |
| {gfx::ColorSpace::PrimaryID::P3, gfx::ColorSpace::MatrixID::RGB}, |
| }); |
| // See CEA 861.G-2018, Sec.7.5.13, "HDR Static Metadata Data Block" for these. |
| constexpr uint8_t kHDRStaticMetadataCapabilityTag = 0x6; |
| constexpr auto kTransferIDMap = std::to_array<gfx::ColorSpace::TransferID>({ |
| gfx::ColorSpace::TransferID::BT709, |
| gfx::ColorSpace::TransferID::GAMMA24, |
| gfx::ColorSpace::TransferID::PQ, |
| // STD B67 is also known as Hybrid-log Gamma (HLG). |
| gfx::ColorSpace::TransferID::HLG, |
| }); |
| constexpr uint8_t kHDRStaticMetadataDataBlockLengthMask = 0x1F; |
| |
| if (edid.size() < kNumExtensionsOffset + 1) { |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kExtensions); |
| return; // Any other fields below are beyond this edid offset. |
| } |
| const uint8_t num_extensions = edid[kNumExtensionsOffset]; |
| |
| for (size_t i = 0; i < num_extensions; ++i) { |
| // Skip parsing the whole extension if size is not enough. |
| if (edid.size() < kExtensionBaseOffset + (i + 1) * kExtensionSize) { |
| break; |
| } |
| |
| const size_t extension_offset = kExtensionBaseOffset + i * kExtensionSize; |
| const uint8_t extention_tag = edid[extension_offset]; |
| const uint8_t revision = edid[extension_offset + 1]; |
| |
| if (extention_tag == kDisplayIdExtensionTag) { |
| ParseDisplayIdExtension(edid, extension_offset); |
| continue; |
| } |
| if (extention_tag != kCEAExtensionTag || |
| revision != kExpectedExtensionRevision) { |
| continue; |
| } |
| |
| const uint8_t timing_descriptors_start = std::min( |
| edid[extension_offset + 2], static_cast<unsigned char>(kExtensionSize)); |
| |
| for (size_t data_offset = extension_offset + kDataBlockOffset; |
| data_offset < extension_offset + timing_descriptors_start;) { |
| // A data block is encoded as: |
| // - byte 1 high 3 bits: tag: '1' for audio, '7' for extended tags. |
| // - byte 1 remaining bits: the length of data block after header. |
| // - byte 2: the extended tag. E.g. '0' for video capability. Values are |
| // defined by the k...CapabilityTag constants. |
| // - byte 3: the capability. |
| const uint8_t tag = edid[data_offset] >> 5; |
| const uint8_t payload_length = edid[data_offset] & 0x1f; |
| if (data_offset + payload_length + 1 > edid.size()) { |
| break; |
| } |
| |
| // Short Audio Descriptors contain passthrough audio support information. |
| // Note: Short Audio Descriptors also contain channel count and sampling |
| // frequency information as described in: |
| // CTA-861-G (2017) section 7.5.2 Audio Data Block. |
| if (tag == kAudioTag) { |
| constexpr uint8_t kCEAShortAudioDescriptorLength = 3; |
| constexpr uint8_t kFormatBitsLPCM = 1; |
| constexpr uint8_t kFormatBitsDTS = 7; |
| constexpr uint8_t kFormatBitsDTSHD = 11; |
| |
| for (int sad_index = 0; |
| sad_index + kCEAShortAudioDescriptorLength <= payload_length; |
| sad_index += kCEAShortAudioDescriptorLength) { |
| switch ((edid[data_offset + 1 + sad_index] >> 3) & 0x1F) { |
| case kFormatBitsLPCM: |
| audio_formats_ |= kAudioBitstreamPcmLinear; |
| break; |
| case kFormatBitsDTS: |
| audio_formats_ |= kAudioBitstreamDts; |
| break; |
| case kFormatBitsDTSHD: |
| audio_formats_ |= kAudioBitstreamDtsHd; |
| break; |
| } |
| } |
| data_offset += payload_length + 1; |
| continue; |
| } |
| |
| if (tag != kExtendedTag || payload_length < 2) { |
| data_offset += payload_length + 1; |
| continue; |
| } |
| |
| switch (edid[data_offset + 1]) { |
| case kExtendedVideoCapabilityTag: |
| // The difference between preferred, IT, and CE video formats doesn't |
| // matter. Set the flag to true if any of these flags are true. |
| overscan_flag_ = |
| (edid[data_offset + 2] & (1 << kPTOverscanFlagPosition)) || |
| (edid[data_offset + 2] & (1 << kITOverscanFlagPosition)) || |
| (edid[data_offset + 2] & (1 << kCEOverscanFlagPosition)); |
| break; |
| |
| case kColorimetryDataBlockCapabilityTag: { |
| constexpr size_t kMaxNumColorimetryEntries = 16; |
| // The Colorimetry Data Block bitfield is 2 bytes long, the second |
| // byte containing the most significant bit (MSB), so it needs to be |
| // shifted to the left to create a 16 bit long value that can be |
| // passed to the bitset constructor. |
| long cdb_bits = edid[data_offset + 2]; |
| if (edid.size() > data_offset + 3) { |
| cdb_bits += edid[data_offset + 3] << 8; |
| } |
| const std::bitset<kMaxNumColorimetryEntries> |
| supported_primaries_bitfield(cdb_bits); |
| static_assert( |
| kMaxNumColorimetryEntries == std::size(kPrimaryMatrixIDMap), |
| "kPrimaryIDMap should describe all possible colorimetry entries"); |
| for (size_t entry = 0; entry < kMaxNumColorimetryEntries; ++entry) { |
| if (supported_primaries_bitfield[entry] && |
| std::get<0>(kPrimaryMatrixIDMap[entry]) != |
| gfx::ColorSpace::PrimaryID::INVALID && |
| std::get<1>(kPrimaryMatrixIDMap[entry]) != |
| gfx::ColorSpace::MatrixID::INVALID) { |
| supported_color_primary_matrix_ids_.insert( |
| kPrimaryMatrixIDMap[entry]); |
| } |
| } |
| break; |
| } |
| |
| case kHDRStaticMetadataCapabilityTag: { |
| constexpr size_t kMaxNumHDRStaticMetadataEntries = 4; |
| const std::bitset<kMaxNumHDRStaticMetadataEntries> |
| supported_eotfs_bitfield(edid[data_offset + 2]); |
| static_assert( |
| kMaxNumHDRStaticMetadataEntries == std::size(kTransferIDMap), |
| "kTransferIDMap should describe all possible transfer entries"); |
| for (size_t entry = 0; entry < kMaxNumHDRStaticMetadataEntries; |
| ++entry) { |
| if (supported_eotfs_bitfield[entry]) { |
| supported_color_transfer_ids_.insert(kTransferIDMap[entry]); |
| } |
| } |
| hdr_static_metadata_ = std::make_optional<gfx::HDRStaticMetadata>({}); |
| hdr_static_metadata_->supported_eotf_mask = |
| base::checked_cast<uint8_t>(supported_eotfs_bitfield.to_ulong()); |
| |
| // See CEA 861.3-2015, Sec.7.5.13, "HDR Static Metadata Data Block" |
| // for details on the following calculations. |
| const uint8_t length_of_data_block = |
| edid[data_offset] & kHDRStaticMetadataDataBlockLengthMask; |
| if (length_of_data_block <= 3) { |
| break; |
| } |
| const uint8_t desired_content_max_luminance = edid[data_offset + 4]; |
| hdr_static_metadata_->max = |
| 50.0 * pow(2, desired_content_max_luminance / 32.0); |
| |
| if (length_of_data_block <= 4) { |
| break; |
| } |
| const uint8_t desired_content_max_frame_average_luminance = |
| edid[data_offset + 5]; |
| hdr_static_metadata_->max_avg = |
| 50.0 * pow(2, desired_content_max_frame_average_luminance / 32.0); |
| |
| if (length_of_data_block <= 5) { |
| break; |
| } |
| const uint8_t desired_content_min_luminance = edid[data_offset + 6]; |
| hdr_static_metadata_->min = |
| hdr_static_metadata_->max * |
| pow(desired_content_min_luminance / 255.0, 2) / 100.0; |
| break; |
| } |
| default: |
| break; |
| } |
| |
| data_offset += payload_length + 1; |
| } |
| } |
| base::UmaHistogramEnumeration(kParseEdidFailureMetric, |
| ParseEdidFailure::kNoError); |
| ReportEdidOptionalsForExternalDisplay(); |
| } |
| |
| // TODO(b/316356595): Move DisplayID parsing into its own class. |
| // NOTE: Refer to figure Figure 2-1 of VESA DisplayID Standard Version 2.1 for |
| // how DisplayID Structure v2.0 is laid out as an EDID extension. |
| void EdidParser::ParseDisplayIdExtension(const std::vector<uint8_t>& edid, |
| size_t extension_offset) { |
| const uint8_t extension_tag = edid[extension_offset]; |
| if (extension_tag != kDisplayIdExtensionTag) { |
| LOG(ERROR) << "Unable to proceed with parsing DisplayID extension as " |
| "extension tag is not for DisplayID (0x70). Actual tag: " |
| << extension_tag; |
| return; |
| } |
| |
| // There are two data blocks that describe tiled displays: |
| // * DisplayID v1.3 with tag 0x12 |
| // * DisplayID v2.0 with tag 0x28 |
| // The v1.3 block is superscede by v2.0. Both of the blocks are laregely |
| // identical. |
| constexpr uint8_t kTiledDisplayDataBlockTag2_0 = 0x28; |
| constexpr uint8_t kTiledDisplayDataBlockTag1_3 = 0x12; |
| |
| // Section data block is divided into (block tag, revision #, number of |
| // payload bytes, payload), where everything except for the payload is one |
| // byte long. |
| constexpr size_t kDataBlockNumPayloadBytesOffset = 2; |
| constexpr size_t kDataBlockNonPayloadBytes = 3; |
| |
| // The EDID-extension section block tag is the first byte |
| // (|extension_offset|), followed by 4 bytes of DisplayID extension section |
| // header, then the data blocks. |
| const size_t displayid_extension_offset = extension_offset + 1; |
| const size_t displayid_data_block_base = displayid_extension_offset + 4; |
| size_t current_data_block_offset = displayid_data_block_base; |
| |
| // The second byte in the extension section header indicates the total number |
| // of bytes in the section data block(s). This should always be 121. |
| const uint8_t num_bytes_in_section_data_blocks = |
| edid[displayid_extension_offset + 1]; |
| if (num_bytes_in_section_data_blocks != 121) { |
| LOG(WARNING) << "Number of bytes in section data block should be 121 " |
| "according to the " |
| "DisplayID spec. Actual # of bytes: " |
| << num_bytes_in_section_data_blocks; |
| return; |
| } |
| |
| const size_t max_offset = |
| std::min(edid.size(), |
| displayid_data_block_base + num_bytes_in_section_data_blocks); |
| while (current_data_block_offset + kDataBlockNumPayloadBytesOffset < |
| max_offset |
| // If there are no remaining data blocks before the fixed 121 bytes of |
| // section data block space runs out, the remaining space is padded |
| // with 0. Since there are no data block tag with ID 0, if a data block |
| // tag is 0 then the rest of the section is just padding. |
| && edid[current_data_block_offset] != 0) { |
| const uint8_t current_data_block_tag = edid[current_data_block_offset]; |
| switch (current_data_block_tag) { |
| case kTiledDisplayDataBlockTag1_3: |
| case kTiledDisplayDataBlockTag2_0: |
| ParseTiledDisplayBlock(edid, current_data_block_offset); |
| break; |
| } |
| // NOTE: Parse other DisplayID blocks here. |
| |
| // Increment |current_data_block_offset| to point to the next data block's |
| // tag (1st byte of the section data block). |
| current_data_block_offset += |
| edid[current_data_block_offset + kDataBlockNumPayloadBytesOffset] + |
| kDataBlockNonPayloadBytes; |
| } |
| } |
| |
| // DisplayID 1.3 and 2.0 tiled display data blocks look identical, at |
| // least for the current set of fields. Consult both of the specs before |
| // parsing more fields. |
| void EdidParser::ParseTiledDisplayBlock(const std::vector<uint8_t>& edid, |
| size_t block_offset) { |
| // See: |
| // https://en.wikipedia.org/wiki/DisplayID#0x28_Tiled_display_topology |
| // "Tile capabilities" is described in the 4th byte (offset + 3). |
| // Bits 2:0 describe "Tile Behavior when It Is the Only Tile Receiving an |
| // Image from the Source". With value of 2 indicating that the tile will |
| // "Scale to fit the display" when it is the only tile receiving an image from |
| // the source. |
| constexpr size_t kTileCapabilitiesOffset = 3; |
| constexpr uint8_t kSingleTileBehaviorBitmask = 0b111; |
| constexpr uint8_t kSingleTileStretchToFit = 0x02; |
| |
| if (edid.size() <= block_offset + kTileCapabilitiesOffset) { |
| return; |
| } |
| |
| tile_can_scale_to_fit_ = |
| (edid[block_offset + kTileCapabilitiesOffset] & |
| kSingleTileBehaviorBitmask) == kSingleTileStretchToFit; |
| } |
| |
| void EdidParser::ReportEdidOptionalsForExternalDisplay() const { |
| if (!is_external_display_) { |
| return; |
| } |
| |
| bool all_optionals_available = true; |
| |
| if (!week_of_manufacture_.has_value()) { |
| all_optionals_available = false; |
| base::UmaHistogramEnumeration(kParseExternalDisplayEdidOptionalsMetric, |
| ParseEdidOptionals::kWeekOfManufacture); |
| } |
| if (!max_image_size_.has_value()) { |
| all_optionals_available = false; |
| base::UmaHistogramEnumeration(kParseExternalDisplayEdidOptionalsMetric, |
| ParseEdidOptionals::kPhysicalSize); |
| } |
| uint8_t serial_number_count = kMaxSerialNumberCount; |
| if (!block_zero_serial_number_hash_.has_value()) { |
| all_optionals_available = false; |
| serial_number_count--; |
| base::UmaHistogramEnumeration(kParseExternalDisplayEdidOptionalsMetric, |
| ParseEdidOptionals::kBlockZeroSerialNumber); |
| } |
| if (!descriptor_block_serial_number_hash_.has_value()) { |
| all_optionals_available = false; |
| serial_number_count--; |
| base::UmaHistogramEnumeration( |
| kParseExternalDisplayEdidOptionalsMetric, |
| ParseEdidOptionals::kDescriptorBlockSerialNumber); |
| } |
| base::UmaHistogramExactLinear(kNumOfSerialNumbersProvidedByExternalDisplay, |
| serial_number_count, kMaxSerialNumberCount); |
| |
| if (all_optionals_available) { |
| base::UmaHistogramEnumeration(kParseExternalDisplayEdidOptionalsMetric, |
| ParseEdidOptionals::kAllAvailable); |
| } |
| } |
| |
| } // namespace display |
