#!/usr/bin/env python  """ Acorn Electron ULA simulation. """  import array import itertools  WIDTH = 640 HEIGHT = 512 INTENSITY = 255  LINES_PER_ROW = 8 MAX_HEIGHT = 256 SCREEN_LIMIT = 0x8000 MAX_MEMORY = 0x10000 BLANK = (0, 0, 0)  def update(screen, ula):      """     Update the 'screen' array by reading from the 'ula'.     """      ula.vsync()     y = 0     while y < HEIGHT:         x = 0         while x < WIDTH:             colour = ula.get_pixel_colour()             pixel = tuple(map(lambda x: x * INTENSITY, colour))             screen[x][y] = pixel             x += 1         ula.hsync()         y += 1  class ULA:      "The ULA functionality."      modes = [         (640, 1, 32), (320, 2, 32), (160, 4, 32),   # (width, depth, rows)         (640, 1, 25), (320, 1, 32), (160, 2, 32),         (320, 1, 25)         ]      palette = range(0, 8) * 2      def __init__(self, memory):          "Initialise the ULA with the given 'memory'."          self.memory = memory         self.set_mode(6)          # Internal state.          self.buffer = [(0, 0, 0)] * 8      def set_mode(self, mode):          """         For the given 'mode', initialise the...            * width in pixels           * colour depth in bits per pixel           * number of character rows           * character row size in bytes           * screen size in bytes           * default screen start address           * horizontal pixel scaling factor           * vertical pixel scaling factor           * line spacing in pixels           * number of entries in the pixel buffer         """          self.width, self.depth, rows = ULA.modes[mode]          row_size = (self.width * self.depth * LINES_PER_ROW) / 8            # bits per row -> bytes per row          # Memory access configuration.         # Note the limitation on positioning the screen start.          screen_size = row_size * rows         self.screen_start = (SCREEN_LIMIT - screen_size) & 0xff00         self.screen_size = SCREEN_LIMIT - self.screen_start          # Scanline configuration.          self.xscale = WIDTH / self.width                                    # pixel width in display pixels         self.yscale = HEIGHT / (rows * LINES_PER_ROW)                       # pixel height in display pixels          self.spacing = MAX_HEIGHT / rows - LINES_PER_ROW                    # pixels between rows          # Start of unused region.          self.footer = rows * LINES_PER_ROW         self.margin = MAX_HEIGHT - rows * (LINES_PER_ROW + self.spacing) + self.spacing          # Internal pixel buffer size.          self.buffer_limit = 8 / self.depth      def vsync(self):          "Signal the start of a frame."          self.line_start = self.address = self.screen_start         self.line = self.line_start % LINES_PER_ROW         self.ysub = 0         self.ssub = 0         self.reset_horizontal()      def reset_horizontal(self):          "Reset horizontal state."          self.xsub = 0         self.buffer_index = self.buffer_limit # need refill      def hsync(self):          "Signal the end of a line."          # Support spacing between character rows.          if self.ssub:             self.ssub -= 1             return          self.reset_horizontal()          # Scale pixels vertically.          self.ysub += 1          # Re-read the current line if appropriate.          if self.ysub < self.yscale:             self.address = self.line_start             return          # Otherwise, move on to the next line.          self.ysub = 0         self.line += 1          # If not on a row boundary, move to the next line.          if self.line % LINES_PER_ROW:             self.address = self.line_start + 1             self.wrap_address()          # After the end of the last line in a row, the address should already         # have been positioned on the last line of the next column.          else:             self.address -= LINES_PER_ROW - 1             self.wrap_address()              # Test for the footer region.              if self.spacing and self.line == self.footer:                 self.ssub = self.margin * self.yscale                 return              # Support spacing between character rows.              self.ssub = self.spacing * self.yscale          self.line_start = self.address      def get_pixel_colour(self):          """         Return a pixel colour by reading from the pixel buffer.         """          # Detect spacing between character rows.          if self.ssub:             return BLANK          # Scale pixels horizontally.          if self.xsub == self.xscale:             self.xsub = 0             self.buffer_index += 1          if self.buffer_index == self.buffer_limit:             self.buffer_index = 0             self.fill_pixel_buffer()          self.xsub += 1         return self.buffer[self.buffer_index]      def fill_pixel_buffer(self):          """         Fill the pixel buffer by translating memory content for the current         mode.         """          byte_value = self.memory[self.address]          i = 0         for colour in decode(byte_value, self.depth):             self.buffer[i] = get_physical_colour(ULA.palette[colour])             i += 1          # Advance to the next column.          self.address += LINES_PER_ROW         self.wrap_address()      def wrap_address(self):         if self.address >= SCREEN_LIMIT:             self.address -= self.screen_size  def get_physical_colour(value):      """     Return the physical colour as an RGB triple for the given 'value'.     """      return value & 1, value >> 1 & 1, value >> 2 & 1  def decode(value, depth):      """     Decode the given byte 'value' according to the 'depth' in bits per pixel,     returning a sequence of pixel values.     """      if depth == 1:         return (value >> 7, value >> 6 & 1, value >> 5 & 1, value >> 4 & 1,                 value >> 3 & 1, value >> 2 & 1, value >> 1 & 1, value & 1)     elif depth == 2:         return (value >> 6 & 2 | value >> 3 & 1, value >> 5 & 2 | value >> 2 & 1,                 value >> 4 & 2 | value >> 1 & 1, value >> 3 & 2 | value & 1)     elif depth == 4:         return (value >> 4 & 8 | value >> 3 & 4 | value >> 2 & 2 | value >> 1 & 1,                 value >> 3 & 8 | value >> 2 & 4 | value >> 1 & 2 | value & 1)     else:         raise ValueError("Only depths of 1, 2 and 4 are supported, not %d." % depth)  # Convenience functions.  def encode(values, depth):      """     Encode the given 'values' according to the 'depth' in bits per pixel,     returning a byte value for the pixels.     """      result = 0      if depth == 1:         for value in values:             result = result << 1 | (value & 1)     elif depth == 2:         for value in values:             result = result << 1 | (value & 2) << 3 | (value & 1)     elif depth == 4:         for value in values:             result = result << 1 | (value & 8) << 3 | (value & 4) << 2 | (value & 2) << 1 | (value & 1)     else:         raise ValueError("Only depths of 1, 2 and 4 are supported, not %d." % depth)      return result  def get_memory():      "Return an array representing the computer's memory."      return array.array("B", itertools.repeat(0, MAX_MEMORY))  def get_screen():      "Return a list of arrays representing the display."      x = 0     screen = []     while x < WIDTH:         y = 0         column = []         while y < HEIGHT:             column.append((0, 0, 0))             y += 1         screen.append(column)         x += 1     return screen  def fill(memory, start, end, value):     for i in xrange(start, end):         memory[i] = value  # Test program providing coverage (necessary for compilers like Shedskin). # NOTE: Running this will actually cause an IndexError.  if __name__ == "__main__":     memory = get_memory()     ula = ULA(memory)     ula.set_mode(6)     fill(memory, 0x6000, 0x8000, encode((1, 0, 1, 0, 1, 0, 1, 0), 1))      # Make a simple two-dimensional array of tuples (three-dimensional in pygame     # terminology).      a = get_screen()     update(a, ula)  # vim: tabstop=4 expandtab shiftwidth=4