Recherche avancée

Sur d’autres sites (7949)

• Blitted OpenGL Textures take less memory and CPU

  16 avril 2015, par Pedro H. Forli

  I’m making a game using pygame + pyopengl, and right now i’m trying to make a video player on this context. To do so I use ffmpeg to load different video formats, then convert each frame to an opengl texture, as designed below, and then play the video.

  class Texture(object):
  
      def __init__(self, data, w=0, h=0):
  
          """
  
          Initialize the texture from 3 diferents types of data:
  
          filename = open the image, get its string and produce texture
  
          surface = get its string and produce texture
  
          string surface = gets it texture and use w and h provided
  
          """
  
          if type(data) == str:
  
              texture_data = self.load_image(data)
  
  
  
          elif type(data) == pygame.Surface:
  
              texture_data = pygame.image.tostring(data, "RGBA", True)
  
              self.w, self.h = data.get_size()
  
  
  
          elif type(data) == bytes:
  
              self.w, self.h = w, h
  
              texture_data = data
  
  
  
          self.texID = 0
  
          self.load_texture(texture_data)
  
  
  
      def load_image(self, data):
  
          texture_surface = pygame.image.load(data).convert_alpha()
  
          texture_data = pygame.image.tostring(texture_surface, "RGBA", True)
  
          self.w, self.h = texture_surface.get_size()
  
  
  
          return texture_data
  
  
  
      def load_texture(self, texture_data):
  
          self.texID = glGenTextures(1)
  
  
  
          glBindTexture(GL_TEXTURE_2D, self.texID)
  
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
  
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
  
          glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.w,
  
                       self.h, 0, GL_RGBA, GL_UNSIGNED_BYTE,
  
                       texture_data)

  Problem is that when i load all the textures of a given video, my RAM goes off the ceiling, about 800mb. But it’s possible to work around this by blitting each texture as it loads, like shown below.

  def render():
  
      glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
  
      glLoadIdentity()
  
      glDisable(GL_LIGHTING)
  
      glEnable(GL_TEXTURE_2D)
  
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
  
      glClearColor(0, 0, 0, 1.0)
  
  
  
  def Draw(texture, top, left, bottom, right):
  
      """
  
      Draw the image on the Opengl Screen
  
      """
  
      # Make sure he is looking at the position (0,0,0)
  
      glBindTexture(GL_TEXTURE_2D, texture.texID)
  
      glBegin(GL_QUADS)
  
  
  
      # The top left of the image must be the indicated position
  
      glTexCoord2f(0.0, 1.0)
  
      glVertex2f(left, top)
  
  
  
      glTexCoord2f(1.0, 1.0)
  
      glVertex2f(right, top)
  
  
  
      glTexCoord2f(1.0, 0.0)
  
      glVertex2f(right, bottom)
  
  
  
      glTexCoord2f(0.0, 0.0)
  
      glVertex2f(left, bottom)
  
  
  
      glEnd()

  def update(t) :
  render()
  Draw(t, -0.5, -0.5, 0.5, 0.5)

  # Check for basic Events on the pygame interface
  
  for event in pygame.event.get():
  
      BASIC_Game.QUIT_Event(event)
  
  
  
  pygame.display.flip()

  Although this reduces the RAM consumption to an acceptable value it makes the loading time bigger than the video length.

  I really don’t understand why opengl works this way, but is there a way to make a texture efficient without blitting it first ?

• Set up a TV like RTMP channel

  17 mars 2015, par JohnWolf

  I’m looking for the best way to play a sequence of videos at specific times on a RTMP channel. Right now, I’ve setup a few things that seem viable to achieve this :

  1. Setup a Wowza Streaming Engine on a server
  2. Setup a Wowza Streaming Cloud account, that receives the stream from the server and broadcasts it with different qualities.

  Now I plugged a RTMP stream into the Wowza Cloud and was able to play it in different qualities on all browsers and devices. That’s the end game.

  I was able to play videos on the stream using ffmpeg and started to work on having video playlists running.

  So my question is simple :

  Do you think it’s a good way to do this ? How would you do it otherwise ?

  Thanks
  John

• Dreamcast Track Sizes

  1er mars 2015, par Multimedia Mike — Sega Dreamcast

  I’ve been playing around with Sega Dreamcast discs lately. Not playing the games on the DC discs, of course, just studying their structure. To review, the Sega Dreamcast game console used special optical discs named GD-ROMs, where the GD stands for “gigadisc”. They are capable of holding about 1 gigabyte of data.

  You know what’s weird about these discs ? Each one manages to actually store a gigabyte of data. Each disc has a CD portion and a GD portion. The CD portion occupies the first 45000 sectors and can be read in any standard CD drive. This area is divided between a brief data track and a brief (usually) audio track.

  The GD region starts at sector 45000. Sometimes, it’s just one humongous data track that consumes the entire GD region. More often, however, the data track is split between the first track and the last track in the region and there are 1 or more audio tracks in between. But the weird thing is, the GD region is always full. I made a study of it (click for a larger, interactive graph) :

  
  
  

  Some discs put special data or audio bonuses in the CD region for players to discover. But every disc manages to fill out the GD region. I checked up on a lot of those audio tracks that divide the GD data and they’re legitimate music tracks. So what’s the motivation ? Why would the data track be split in 2 pieces like that ?

  I eventually realized that I probably answered this question in this blog post from 4 years ago. The read speed from the outside of an optical disc is higher than the inside of the same disc. When I inspect the outer data tracks of some of these discs, sure enough, there seem to be timing-sensitive multimedia FMV files living on the outer stretches.

  One day, I’ll write a utility to take apart the split ISO-9660 filesystem offset from a weird sector.