Git Repositories

Use the vesa modes information from Wikipedia and discard other modes not fully docum...
authorCyrille Pontvieux <cyrille.pontvieux@april-waf.com>
Tue, 10 Dec 2013 22:16:29 +0000 (23:16 +0100)
committerCyrille Pontvieux <cyrille.pontvieux@april-waf.com>
Tue, 10 Dec 2013 22:16:29 +0000 (23:16 +0100)
Also use another way to determine the correct mode, prefer a higher resolution with less colors than more colors with less resolution.

src/lib/lilo.py

index d18b5ab..50a3c8d 100644 (file)
@@ -16,6 +16,7 @@ import glob
 import codecs
 import salix_livetools_library as sltl
 import subprocess
+from operator import itemgetter
 
 class Lilo:
   
@@ -284,104 +285,92 @@ vga = {vga}
     mode = None
     label = None
     if fbGeometry:
-      vesaModes = {
-          4: {
-            200: { 320: None },
-            400: { 640: None },
-            480: { 640: None },
-            500: { 800: None },
-            600: { 800: 770 },
-            640: { 1024: None },
-            672: { 896: None },
-            720: { 1152: None },
-            768: { 1024: 772 },
-            800: { 1280: None },
-            900: { 1440: None },
-            1024: { 1280: 774 },
-            1050: { 1400: None },
-            1200: { 1600: None, 1920: None },
-          },
-          8: {
-            200: { 320: None },
-            400: { 640: 768 },
-            480: { 640: 769 },
-            500: { 800: 879 },
-            600: { 800: 771 },
-            640: { 1024: 874 },
-            672: { 896: 815 },
-            720: { 1152: 869 },
-            768: { 1024: 773 },
-            800: { 1280: 864 },
-            900: { 1440: 864 },
-            1024: { 1280: 775 },
-            1050: { 1400: 796 },
-            1200: { 1600: 796, 1920: 893 },
-          },
-          15: {
-            200: { 320: 781 },
-            400: { 640: 801 },
-            480: { 640: 784 },
-            500: { 800: 880 },
-            600: { 800: 787 },
-            640: { 1024: 875 },
-            672: { 896: 816 },
-            720: { 1152: 870 },
-            768: { 1024: 790 },
-            800: { 1280: 865 },
-            900: { 1440: 865 },
-            1024: { 1280: 793 },
-            1050: { 1400: 797 },
-            1200: { 1600: 797, 1920: 894 },
-          },
-          16: {
-            200: { 320: 782 },
-            400: { 640: 802 },
-            480: { 640: 785 },
-            500: { 800: 881 },
-            600: { 800: 788 },
-            640: { 1024: 876 },
-            672: { 896: 817 },
-            720: { 1152: 871 },
-            768: { 1024: 791 },
-            800: { 1280: 866 },
-            900: { 1440: 866 },
-            1024: { 1280: 794 },
-            1050: { 1400: 798 },
-            1200: { 1600: 798, 1920: 895 },
-          },
-          24: {
-            200: { 320: 783 },
-            400: { 640: 803 },
-            480: { 640: 786 },
-            500: { 800: 882 },
-            600: { 800: 789 },
-            640: { 1024: 877 },
-            672: { 896: 818 },
-            720: { 1152: 872 },
-            768: { 1024: 792 },
-            800: { 1280: 867 },
-            900: { 1440: 867 },
-            1024: { 1280: 795 },
-            1050: { 1400: 799 },
-            1200: { 1600: 799, 1920: 896 },
-          },
-          32: {
-            200: { 320: None },
-            400: { 640: 804 },
-            480: { 640: 809 },
-            500: { 800: 883 },
-            600: { 800: 814 },
-            640: { 1024: 878 },
-            672: { 896: 819 },
-            720: { 1152: 873 },
-            768: { 1024: 824 },
-            800: { 1280: 868 },
-            900: { 1440: 868 },
-            1024: { 1280: 829 },
-            1050: { 1400: 834 },
-            1200: { 1600: 834, 1920: 897 },
-          }
-        }
+      vesaModes = [
+          (320, 200, 4, None),
+          (640, 400, 4, None),
+          (640, 480, 4, None),
+          (800, 500, 4, None),
+          (800, 600, 4, 770),
+          (1024, 640, 4, None),
+          (896, 672, 4, None),
+          (1152, 720, 4, None),
+          (1024, 768, 4, 772),
+          (1440, 900, 4, None),
+          (1280, 1024, 4, 774),
+          (1400, 1050, 4, None),
+          (1600, 1200, 4, None),
+          (1920, 1200, 4, None),
+          (320, 200, 8, None),
+          (640, 400, 8, 768),
+          (640, 480, 8, 769),
+          (800, 500, 8, 879),
+          (800, 600, 8, 771),
+          (1024, 640, 8, 874),
+          (896, 672, 8, 815),
+          (1152, 720, 8, 869),
+          (1024, 768, 8, 773),
+          (1440, 900, 8, 864),
+          (1280, 1024, 8, 775),
+          (1400, 1050, 8, 835),
+          (1600, 1200, 8, 796),
+          (1920, 1200, 8, 893),
+          (320, 200, 15, 781),
+          (640, 400, 15, 801),
+          (640, 480, 15, 784),
+          (800, 500, 15, 880),
+          (800, 600, 15, 787),
+          (1024, 640, 15, 875),
+          (896, 672, 15, 816),
+          (1152, 720, 15, 870),
+          (1024, 768, 15, 790),
+          (1440, 900, 15, 865),
+          (1280, 1024, 15, 793),
+          (1400, 1050, 15, None),
+          (1600, 1200, 15, 797),
+          (1920, 1200, 15, None),
+          (320, 200, 16, 782),
+          (640, 400, 16, 802),
+          (640, 480, 16, 785),
+          (800, 500, 16, 881),
+          (800, 600, 16, 788),
+          (1024, 640, 16, 876),
+          (896, 672, 16, 817),
+          (1152, 720, 16, 871),
+          (1024, 768, 16, 791),
+          (1440, 900, 16, 866),
+          (1280, 1024, 16, 794),
+          (1400, 1050, 16, 837),
+          (1600, 1200, 16, 798),
+          (1920, 1200, 16, None),
+          (320, 200, 24, 783),
+          (640, 400, 24, 803),
+          (640, 480, 24, 786),
+          (800, 500, 24, 882),
+          (800, 600, 24, 789),
+          (1024, 640, 24, 877),
+          (896, 672, 24, 818),
+          (1152, 720, 24, 872),
+          (1024, 768, 24, 792),
+          (1440, 900, 24, 867),
+          (1280, 1024, 24, 795),
+          (1400, 1050, 24, 838),
+          (1600, 1200, 24, 799),
+          (1920, 1200, 24, None),
+          (320, 200, 32, None),
+          (640, 400, 32, 804),
+          (640, 480, 32, 809),
+          (800, 500, 32, 883),
+          (800, 600, 32, 814),
+          (1024, 640, 32, 878),
+          (896, 672, 32, 819),
+          (1152, 720, 32, 873),
+          (1024, 768, 32, 824),
+          (1440, 900, 32, 868),
+          (1280, 1024, 32, 829),
+          (1400, 1050, 32, None),
+          (1600, 1200, 32, 834),
+          (1920, 1200, 32, None),
+        ]
       values = fbGeometry[0].strip().split(' ')
       self.__debug("FB Values: " + unicode(values))
       xRes = int(values[1])
@@ -389,22 +378,21 @@ vga = {vga}
       deep = int(values[-1])
       xMax = None
       yMax = None
-      if deep in vesaModes:
-        for y in sorted(list(vesaModes[deep]), reverse = True):
-          self.__debug("trying {0} for y".format(y))
-          if y <= yRes:
+      dMax = None
+      # order the vesa modes by vertical size desc, horizontal size desc, color depth desc.
+      for vesaMode in sorted(vesaModes, key = itemgetter(1, 0, 2), reverse = True):
+        (x, y, d, m) = vesaMode
+        if m:
+          self.__debug("trying {0} for y, {1} for x and {2} for d".format(y, x, d))
+          if y <= yRes and x <= xRes and d <= deep:
+            xMax = x
             yMax = y
+            dMax = d
+            mode = m
             break
-        if yMax:
-          for x in sorted(list(vesaModes[deep][yMax]), reverse = True):
-            self.__debug("trying {0} for x".format(x))
-            if x <= xRes:
-              xMax = x
-              break
-      self.__debug("Max X×Y found: {x}×{y}".format(x = xMax, y = yMax))
-      if xMax and yMax:
-        mode = vesaModes[deep][yMax][xMax]
-        label = "{x}x{y}x{d}".format(x = xMax, y = yMax, d = deep)
+      if mode:
+        self.__debug("Max mode found: {x}×{y}×{d}".format(x = xMax, y = yMax, d = dMax))
+        label = "{x}x{y}x{d}".format(x = xMax, y = yMax, d = dMax)
     if not mode:
       mode = 'normal'
       label = 'text'