Add feature to match display's native resolution

Accepts new setup definitions like

DP-1 native_resolution=3840x2160
eDP-1 00ffffff...

To match any monitors attached as DP-1 with native resolution of 3840x2160

Author: Ackerley Tng

autorandr.py

@@ -159,6 +159,174 @@ def is_closed_lid(output):
     return False
 
 
+def _read_resolution_from_18_byte_data_block(edid, offset):
+    """Read resolution from edid bytearray beginning at offset. Return a tuple
+    of (horizontal, vertical) pixels if a valid resolution is defined, else
+    return None"""
+
+    horz = edid[offset + 2] + ((edid[offset + 4] & 0xf0) << 4)
+    if horz == 0:
+        return None
+
+    vert = edid[offset + 5] + ((edid[offset + 7] & 0xf0) << 4)
+
+    return (horz, vert)
+
+
+def _read_resolutions_from_base_block(edid, offset):
+    resolutions = []
+
+    detail = 0x36
+    for _ in range(4):
+        res = _read_resolution_from_18_byte_data_block(edid, offset + detail)
+        if res:
+            resolutions.append(res)
+
+        detail += 18
+
+    return resolutions
+
+
+def _read_resolutions_from_cta_block(edid, offset):
+    version = edid[offset + 1]
+    if version < 1:
+        return []
+
+    detail = edid[offset + 2]
+    if detail < 4:
+        return []
+
+    resolutions = []
+    while detail < 127:
+        res = _read_resolution_from_18_byte_data_block(edid, offset + detail)
+        if res:
+            resolutions.append(res)
+
+        detail += 18
+
+    return resolutions
+
+
+def _read_resolution_from_displayid_block_0x01(edid, offset):
+    payload_length = edid[offset + 2]
+
+    if payload_length != 12:
+        return None
+
+    horz = (edid[offset + 8] << 8) + edid[offset + 7]
+    if horz == 0:
+        return None
+
+    vert = (edid[offset + 10] << 8) + edid[offset + 9]
+
+    return (horz, vert)
+
+
+def _read_resolution_from_displayid_block_0x0c(edid, offset):
+    payload_length = edid[offset + 2]
+
+    if payload_length != 13:
+        return None
+
+    horz = (edid[offset + 6] << 8) + edid[offset + 5] + 1
+    if horz == 0:
+        return None
+
+    vert = (edid[offset + 8] << 8) + edid[offset + 7] + 1
+
+    return (horz, vert)
+
+
+def _read_resolution_from_displayid_block_0x21(edid, offset):
+    payload_length = edid[offset + 2]
+
+    if payload_length != 29:
+        return None
+
+    horz = (edid[offset + 8] << 8) + edid[offset + 7]
+    if horz == 0:
+        return None
+
+    vert = (edid[offset + 10] << 8) + edid[offset + 9]
+
+    return (horz, vert)
+
+
+def _read_resolution_from_displayid_block(edid, offset):
+    tag = edid[offset]
+    payload_length = edid[offset + 2]
+
+    if tag == 0x01:
+        res = _read_resolution_from_displayid_block_0x01(edid, offset)
+    elif tag == 0x0c:
+        res = _read_resolution_from_displayid_block_0x0c(edid, offset)
+    elif tag == 0x21:
+        res = _read_resolution_from_displayid_block_0x21(edid, offset)
+    else:
+        res = None
+
+    # Add header length of 3
+    return payload_length + 3, res
+
+
+def _read_resolutions_from_displayid_block(edid, offset):
+    # DisplayID length has a maximum of 121
+    total_length = min(edid[offset + 2], 121)
+    base = offset + 5
+
+    resolutions = []
+    detail = 0
+    while detail < total_length:
+        block_length, resolution = \
+            _read_resolution_from_displayid_block(edid, base + detail)
+        if resolution:
+            resolutions.append(resolution)
+
+        detail += block_length
+
+    return resolutions
+
+
+def _read_resolutions_from_block(edid, offset):
+    block_type = edid[offset]
+
+    if block_type == 0x00:
+        return _read_resolutions_from_base_block(edid, offset)
+    if block_type == 0x02:
+        return _read_resolutions_from_cta_block(edid, offset)
+    if block_type == 0x70:
+        return _read_resolutions_from_displayid_block(edid, offset)
+
+    return []
+
+
+def read_native_resolutions(edid):
+    """Given an edid hex string, return a set of all the native resolutions
+    (horizontal, vertical) defined in the EDID"""
+
+    edid_page_size = 128
+
+    edid_bytearray = bytearray.fromhex(edid)
+
+    native_resolutions = set()
+    for offset in range(0, len(edid_bytearray), edid_page_size):
+        native_resolutions.update(_read_resolutions_from_block(edid_bytearray, offset))
+
+    return native_resolutions
+
+
+def _parse_edid_pattern(pattern):
+    """Parse (horizontal, vertical) pixels from a pattern defined like  """
+
+    # Only supports patterns like "native_resolution=3840x2160" for now
+    if "native_resolution=" not in pattern:
+        return None
+
+    m = re.match(r"native_resolution=(\d+)x(\d+)", pattern)
+    if m:
+        return (int(m.group(1)), int(m.group(2)))
+
+
 class AutorandrException(Exception):
     def __init__(self, message, original_exception=None, report_bug=False):
         self.message = message
@@ -361,6 +529,8 @@ def parse_serial_from_edid(self):
                 return
             if "*" in self.edid:
                 return
+            if _parse_edid_pattern(self.edid):
+                return
             # Thx to pyedid project, the following code was
             # copied (and modified) from pyedid/__init__py:21 [parse_edid()]
             raw = bytes.fromhex(self.edid)
@@ -551,6 +721,10 @@ def edid_equals(self, other):
                 return match_asterisk(self.edid, other.edid) > 0
             elif "*" in other.edid:
                 return match_asterisk(other.edid, self.edid) > 0
+            if _parse_edid_pattern(self.edid):
+                return match_native_resolution(self.edid, other.edid)
+            elif _parse_edid_pattern(other.edid):
+                return match_native_resolution(other.edid, self.edid)
         return self.edid == other.edid
 
     def __ne__(self, other):
@@ -721,6 +895,14 @@ def match_asterisk(pattern, data):
     return matched * 1. / total
 
 
+def match_native_resolution(edid_pattern, edid_string):
+    horz_x_vert = _parse_edid_pattern(edid_pattern)
+    if not horz_x_vert:
+        return False
+
+    return horz_x_vert in read_native_resolutions(edid_string)
+
+
 def update_profiles_edid(profiles, config):
     fp_map = {}
     for c in config:
@@ -766,8 +948,14 @@ def find_profiles(current_config, profiles):
         if not matches or any((name not in config.keys() for name in current_config.keys() if current_config[name].fingerprint)):
             continue
         if matches:
-            closeness = max(match_asterisk(output.edid, current_config[name].edid), match_asterisk(
-                current_config[name].edid, output.edid))
+            config_edid = current_config[name].edid
+            parsed = _parse_edid_pattern(output.edid) or _parse_edid_pattern(config_edid)
+            if parsed:
+                closeness = int(match_native_resolution(config_edid, output.edid) or
+                                match_native_resolution(output.edid, config_edid))
+            else:
+                closeness = max(match_asterisk(output.edid, config_edid),
+                                match_asterisk(config_edid, output.edid))
             detected_profiles.append((closeness, profile_name))
     detected_profiles = [o[1] for o in sorted(detected_profiles, key=lambda x: -x[0])]
     return detected_profiles