Recherche avancée

Sur d’autres sites (7922)

• Android - How to merge the 2 video SIDE by SIDE ? [on hold]

  25 avril 2015, par Lakshmanan

  I want merge two video file (Mp4 file) SIDE BY SIDE. I have tried with following option.

  1) FFMPEG - It is just merging one after another.

  2) mp4parser - It is also did the same, I can merge it by one after another.

  3) Tried Screen Capture Android - > I can merge it side by side, But in the Screen Capture i could not get the Audio of the file.

  The Purpose of this merging is, I have a main screen, which have some game play, user can touch on some portion of the screen it will play some sound as well as some animation.

  I have the Record option in my game screen, So when user click on the record option, I need to record the user face reaction via Front camera as well as the Game Play , So once record is completed I need to play the Game recording as left side and face recording video as right side.

  I did this using by saving touch event in the Database and played in left side of the screen at right side I played the video which is recorded by Front Camera.

  But i need to share this same video to social media, For this I need as single video. So i can screen capture the Game Play(left side) as video file and also i have the Front camera recorded video. So i need to merge this two video as single video as like its playing in my app to share.

  Please let me know is there any way to do this.

• 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