title: Asynchronous image load in pygame
body: <p>I am writing a small application in python 2.7 using pygame in which I would like to smoothly display animated tiles on screen. I am writing on Ubuntu, but target platform is Raspberry Pi if that's relevant. The challenge is that the textures for these animated tiles are stored on a web server and are to be loaded dynamically over time, not all at once. I'd like to be able to load these images into pygame with no noticeable hitch in my animation or input response. The load frequency is pretty low, like grabbing a couple jpgs every 30 seconds. I am willing to wait a long time for the image to load in the background if it means the main input/animation thread remains unhitched.</p>
  
  <p>So using the multiprocessing module, I am able to download images from a server asynchronously into a buffer, and then pass this buffer to my main pygame process over a multiprocessing.queues.SimpleQueue object. However, once the buffer is accessible in the pygame process, there is still a hitch in my application while the buffer is loaded into a Surface for blitting via pygame.image.frombuffer().</p>
  
  <p>Is there a way to make this pygame.image.load() call asynchronous so that my animation in the game, etc is not blocked? I can't think of an obvious solution due to GIL.</p>
  
  <p>If I was writing a regular OpenGL program in C, I would be able to asynchronously write data to the GPU using a pixel buffer object, correct? Does pygame expose any part of this API by any chance? I can't seem to find it in the pygame docs, which I am pretty new to, so pardon me if the answer is obvious. Any help pointing out how pygame's terminology translates to OpenGL API would be a big help, as well any relevant examples in which pygame can initialize a texture asynchronously would be amazing!</p>
  
  <p>If pygame doesn't offer this functionality, what are my options? Is there a way to do this is with PySDL2?</p>
  
  <p>EDIT: Ok, so I tried using pygame.image.frombuffer, and it doesn't really cut down on the hitching I am seeing. Any ideas of how I can make this image load truly asynchronous? Here is some code snippets illustrating what I am currently doing.</p>
  
  <p>Here's the async code I have that sits in a separate process from pygame</p>
  
  <pre><code>def _worker(in_queue, out_queue):
      done = False
      while not done:
          if not in_queue.empty():
              obj = in_queue.get()
              # if a bool is passed down the queue, set the done flag
              if isinstance(obj, bool):
                  done = obj
              else:
                  url, w, h = obj
                  # grab jpg at given url. It is compressed so we use PIL to parse it
                  jpg_encoded_str = urllib2.urlopen(url).read()
                  # PIL.ImageFile
                  parser = ImageFile.Parser()
                  parser.feed(jpg_encoded_str)
                  pil_image = parser.close() 
                  buff = pil_image.tostring()
                  # place decompressed buffer into queue for consumption by main thread
                  out_queue.put((url, w, h, buff))
  
  # and so I create a subprocess that runs _worker function
  </code></pre>
  
  <p>Here's my update loop that runs in the main thread. It looks to see if the _Worker process has put anything into the out_queue, and if so loads it into pygame:</p>
  
  <pre><code>def update():
      if not out_queue.empty():
          url, w, h, buff = img_buffer_queue.get()
          # This call is where I get a hitch in my application
          image = pygame.image.frombuffer(buff, (w, h), "RGB")
          # Place loaded image on the pygame.Sprite, etc in the callback
          callback = on_load_callbacks.pop(url, None)
          if callback:
              callback(image, w, h)
  </code></pre>