def testGetEstablishedTimingBitmap(self):
establishedTimingBitmaps = [0x210800, 0x200000, 0, 0]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getEstablishedTimingBitmap(),
establishedTimingBitmaps[key])
def create_screen(sc_line, modes, edid_data, connected):
name = sc_line.split(' ')[0]
model = ""
manufacturer_id = ""
manufacturer = ""
product_id = 0
serial_no = 0
physical_width = 30.0
physical_height = 30.0
if(len(edid_data) > 0):
bytes = hex2bytes("".join(edid_data[0:8]))
parsed_edid = Edid(bytes)
model = parsed_edid.name if parsed_edid.name else ""
manufacturer_id = parsed_edid.manufacturer_id
manufacturer = parsed_edid.manufacturer
physical_width = parsed_edid.width
physical_height = parsed_edid.height
product_id = parsed_edid.product
serial_no = parsed_edid.serial_no
# Set dpi of modes
for mode in modes:
mode.dpi = mode.height / (physical_height/2.54)
# if connected
rot = None
if modes:
fr = sc_line.split(' ')
if len(fr) > 2:
rot = str_to_rot(sc_line.split(' ')[3])
return Screen(name, 'primary' in sc_line, rot, modes, manufacturer_id, manufacturer, model, physical_width, physical_height, product_id, serial_no, connected)
def testGetMaximumVerticalImageSize(self):
maximumVerticalImageSizes = [900, 1300, 3400, 1400]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getMaximumVerticalImageSize(),
maximumVerticalImageSizes[key])
def testGetSupportedFeaturesBitmap(self):
supportedFeaturesBitmaps = [0x0A, 0x05, 0x22, 0x0A]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getSupportedFeaturesBitmap(),
supportedFeaturesBitmaps[key])
def testGetVideoInputParametersBitmap(self):
videoInputParametersBitmaps = [0x80, 0x08, 0xB5, 0x80]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getVideoInputParametersBitmap(),
videoInputParametersBitmaps[key])
def testGetMaximumHorizontalImageSize(self):
maximumHorizontalImageSizes = [16, 17, 60, 26]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getMaximumHorizontalImageSize(),
maximumHorizontalImageSizes[key])
def testGetYearOfManufacture(self):
yearOfManufactures = [2007, 2011, 2014, 2010]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getYearOfManufacture(),
yearOfManufactures[key])
def testGetWeekOfManufacture(self):
weekOfManufactures = [47, 12, 12, 32]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getWeekOfManufacture(),
weekOfManufactures[key])
def testGetManufacturerProductCode(self):
manufacturerProductCodes = [956, 256, 44547, 0x3DC4]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getManufacturerProductCode(),
manufacturerProductCodes[key])
def get_resolutions_display(self, disp):
'''return a list of resolutions for the specified display'''
# hash resolutions to avoid probing them twice
if disp in self._resolutions: return self._resolutions[disp]
# get supported resolutions from driver
r = ResolutionList(self.backend.get_display_supported_res(disp))
if len(r) == 0:
r = ResolutionList('800x600, 640x480')
self.log.warning(
'no resolutions found for display %s, falling back to: %s' %
(disp, r))
# bump weight of flat-panel display with 1000
res = self.backend.get_display_preferred_res(disp)
if res:
res = Resolution(res)
if res in r: r[r.index(res)].weight += 1000
else: r.append(res)
# bump weight of EDID resolutions with 100
edid_data = self.backend.get_display_edid(disp)
if edid_data:
edid = Edid(edid_data)
for d in edid.get_monitor_details():
title, info = d
if title != 'Detailed Timing': continue
res = Resolution(
[info['horizontal_active'], info['vertical_active']])
if res in r: r[r.index(res)].weight += 100
else: r.append(res)
self.log.info('resolutions of ' + str(disp) + ': ' +
', '.join(map(str, sorted(r))))
self._resolutions[disp] = r
return r
def testGetNumberOfExtensions(self):
numberOfExtensions = [1, 0, 2, 1]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
self.assertEqual(
edid.getNumberOfExtensions(),
numberOfExtensions[key])
def testCalculateChecksum(self):
edid = Edid(data=bytearray(128))
# put wrong checksum
edid[127] = 42
edid.calculateChecksum()
self.assertTrue(edid.checkChecksum())
self.assertEqual(edid[127], 0x00)
def testCalculateChecksum2(self):
edid = Edid(data=bytearray(128))
# change data
edid[0] = 1
edid.calculateChecksum()
self.assertTrue(edid.checkChecksum())
self.assertEqual(edid[127], 255)
def testGetChromaticityCoordinatesGreen(self):
chromaticityCoordinatesGreen = [(0.300, 0.600), (0.0, 0.0),
(0.295, 0.625), (0.339, 0.568)]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
coordinates = edid.getChromaticityCoordinatesGreen()
self.assertAlmostEqual(coordinates[0],
chromaticityCoordinatesGreen[key][0],
places=3)
self.assertAlmostEqual(coordinates[1],
chromaticityCoordinatesGreen[key][1],
places=3)
def testGetChromaticityCoordinatesBlue(self):
chromaticityCoordinatesBlues = [(0.150, 0.060), (0.0, 0.0),
(0.148, 0.047), (0.153, 0.124)]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
coordinates = edid.getChromaticityCoordinatesBlue()
self.assertAlmostEqual(coordinates[0],
chromaticityCoordinatesBlues[key][0],
places=3)
self.assertAlmostEqual(coordinates[1],
chromaticityCoordinatesBlues[key][1],
places=3)
def testGetChromaticityCoordinatesRed(self):
chromaticityCoordinatesReds = [(0.640, 0.330), (0.0, 0.0),
(0.655, 0.332), (0.573, 0.358)]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
coordinates = edid.getChromaticityCoordinatesRed()
self.assertAlmostEqual(coordinates[0],
chromaticityCoordinatesReds[key][0],
places=3)
self.assertAlmostEqual(coordinates[1],
chromaticityCoordinatesReds[key][1],
places=3)
def testCalculateChecksum3(self):
edid = Edid(data=bytearray(128))
for i in range(0, 127):
edid[i] = 2
# Databytes: 127 * 2 = 254
# Checksum: 2
# Sum: 256 % 256 = 0
edid.calculateChecksum()
self.assertTrue(edid.checkChecksum())
self.assertEqual(edid[127], 2)
def testGetChromaticityCoordinatesWhite(self):
chromaticityCoordinatesWhites = [(0.312, 0.329), (0.0, 0.0),
(0.313, 0.329), (0.313, 0.329)]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
coordinates = edid.getChromaticityCoordinatesWhite()
self.assertAlmostEqual(coordinates[0],
chromaticityCoordinatesWhites[key][0],
places=3)
self.assertAlmostEqual(coordinates[1],
chromaticityCoordinatesWhites[key][1],
places=3)
def testSetStandardTimingInformation(self):
for index in range(0, 8):
edid = Edid(version=1.2)
edid.setStandardTimingInformation(index, 640, 1.0, 70)
self.assertEqual(edid[38 + 2 * index + 0], 49)
self.assertEqual(edid[38 + 2 * index + 1], 10)
edid = Edid(version=1.3)
edid.setStandardTimingInformation(index, None, None, None)
self.assertEqual(edid[38 + 2 * index + 0], 1)
self.assertEqual(edid[38 + 2 * index + 1], 1)
edid = Edid(version=1.3)
edid.setStandardTimingInformation(index, 256, 16.0 / 10.0, 80)
self.assertEqual(edid[38 + 2 * index + 0], 1)
self.assertEqual(edid[38 + 2 * index + 1], 20)
edid = Edid(version=1.3)
edid.setStandardTimingInformation(index, 1024, 4.0 / 3.0, 90)
self.assertEqual(edid[38 + 2 * index + 0], 97)
self.assertEqual(edid[38 + 2 * index + 1], 94)
edid = Edid(version=1.3)
edid.setStandardTimingInformation(index, 1600, 5.0 / 4.0, 100)
self.assertEqual(edid[38 + 2 * index + 0], 169)
self.assertEqual(edid[38 + 2 * index + 1], 168)
edid = Edid(version=1.3)
edid.setStandardTimingInformation(index, 1920, 16.0 / 9.0, 120)
self.assertEqual(edid[38 + 2 * index + 0], 209)
self.assertEqual(edid[38 + 2 * index + 1], 252)
def testGetStandardTimingInformation(self):
standardTimingInformations = [[(1280, 5.0 / 4.0, 60),
(1600, 4.0 / 3.0, 60)],
[(640, 4.0 / 3.0, 60)], [], []]
for key, data in enumerate(self.VALID_EDID_DATA):
edid = Edid(data=data)
for index in range(0, 8):
standardTimingInformation = edid.getStandardTimingInformation(
index)
correctStandardTimingInformation = standardTimingInformations[
key][index] if index < len(
standardTimingInformations[key]) else (None, None,
None)
self.assertEqual(standardTimingInformation[0],
correctStandardTimingInformation[0])
self.assertEqual(standardTimingInformation[1],
correctStandardTimingInformation[1])
self.assertEqual(standardTimingInformation[2],
correctStandardTimingInformation[2])
def get_edids():
output = xrandr._output("--verbose")
display = None
edid = None
edids_by_display = {}
for line in output.split('\n'):
if 'connected' in line:
display = line.split(' ')[0]
elif line.startswith('\tEDID'):
edid = ""
elif line.startswith('\t\t') and edid is not None:
edid += line.strip()
elif not line.startswith('\t\t') and edid is not None:
edid = bytes(
[int("".join(pair), 16) for pair in zip(*[iter(edid)] * 2)])
edids_by_display[display] = Edid(edid)
edid = None
display = None
return edids_by_display
def testSetEstablishedTimingBitmap(self):
edid = Edid(data=bytearray(128))
edid.setEstablishedTimingBitmap(0x123456)
self.assertEqual(edid[35:38], bytearray.fromhex('12 34 56'))
def testSetChromaticityCoordinatesBlue(self):
edid = Edid(data=bytearray(128))
edid.setChromaticityCoordinatesBlue(0.888, 0.777)
self.assertEqual(edid[26], 0x10)
self.assertEqual(edid[31], 0xE3)
self.assertEqual(edid[32], 0xC7)
def testCalculateChecksum(self):
edid = Edid(data=bytearray(128))
edid[-1] = 42
edid.calculateChecksum()
self.assertEqual(edid[127], 0x00)
def testSetChromaticityCoordinatesRed(self):
edid = Edid(data=bytearray(128))
edid.setChromaticityCoordinatesRed(0.888, 0.777)
self.assertEqual(edid[25], 0x10)
self.assertEqual(edid[27], 0xE3)
self.assertEqual(edid[28], 0xC7)
def testCheckChecksumInvalid(self):
edid = Edid(data=self.VALID_EDID_DATA[0])
edid[127] = 0
self.assertFalse(edid.checkChecksum())
def testCheckChecksumValid(self):
for data in self.VALID_EDID_DATA:
edid = Edid(data=data)
self.assertTrue(edid.checkChecksum())
def testSetNumberOfExtensions(self):
edid = Edid(version=1.3)
edid.setNumberOfExtensions(2)
self.assertEqual(edid[126], 2)
def testSetChromaticityCoordinatesGreen(self):
edid = Edid(data=bytearray(128))
edid.setChromaticityCoordinatesGreen(0.888, 0.777)
self.assertEqual(edid[25], 0x01)
self.assertEqual(edid[29], 0xE3)
self.assertEqual(edid[30], 0xC7)
def testSetChromaticityCoordinatesWhite(self):
edid = Edid(data=bytearray(128))
edid.setChromaticityCoordinatesWhite(0.888, 0.777)
self.assertEqual(edid[26], 0x01)
self.assertEqual(edid[33], 0xE3)
self.assertEqual(edid[34], 0xC7)
