Recherche avancée

Sur d’autres sites (9435)

• PNG sequence to MP4 while looping the animation

  19 avril 2016, par user245115

  So, I’m trying to convert a PNG sequence to an MP4 and loop the animation about 100 times, the only problem is my script doesn’t seem to be working properly.

  What the script is supposed to do is get the number of PNG files in the frames directory, and send them to FFMPEG 100 times. Only problem is my script isn’t working right. Here’s the code.

  #!/bin/bash
  
  
  
  loopcode()
  
  {
  
  tmpdir=frames
  
  picext=png
  
  one=$(ls -l ${tmpdir}/*.png  | wc -l)
  
  two=$(echo "${one}+0" | bc -l)
  
  three=0
  
  while [ ! ${loopi} -eq ${looper} ]; do
  
    while [ ! ${three} -eq ${two} ]; do
  
      three=$(printf "%09d" ${two})
  
      echo ${tmpdir}/${three}.${picext}
  
      two=$(echo "${two}+1" | bc -l)
  
    done
  
    two=0
  
    loopi=$(echo "${loopi}+1" | bc -l)
  
  done
  
  }
  
  
  
  looper=100
  
  loopi=0
  
  outfile=output.mp4
  
  fps=5
  
  convert frames/*.png frames/%09d.jpeg
  
  loopcode && sleep 5
  
  cat $(loopcode) | ffmpeg -framerate 1/5 -i - -c:v libx264 -r 30 -pix_fmt yuv420p "${outfile}"

• Surface Texture object is not getting the frames from a Surface Class

  22 avril 2016, par Juan Manuel González Otero

  On the one hand, I have a Surface Class which when instantiated, automatically initialize a new thread and start grabbing frames from a streaming source via native code based on FFMPEG. Here is the main parts of the code for the aforementioned Surface Class :

   public class StreamingSurface extends Surface implements Runnable {
  
  
  
      ...
  
  
  
      public StreamingSurface(SurfaceTexture surfaceTexture, int width, int height) {
  
          super(surfaceTexture);
  
  
  
          screenWidth  = width;
  
          screenHeight = height;      
  
          init();
  
  
  
      }
  
  
  
      public void init() {
  
          mDrawTop = 0;
  
          mDrawLeft = 0;
  
          mVideoCurrentFrame = 0;
  
          this.setVideoFile();
  
          this.startPlay();
  
      }
  
  
  
      public void setVideoFile() {        
  
          // Initialise FFMPEG
  
          naInit("");
  
  
  
          // Get stream video res
  
          int[] res = naGetVideoRes();
  
          mDisplayWidth = (int)(res[0]);
  
          mDisplayHeight = (int)(res[1]);
  
  
  
          // Prepare Display
  
          mBitmap = Bitmap.createBitmap(mDisplayWidth, mDisplayHeight, Bitmap.Config.ARGB_8888);
  
          naPrepareDisplay(mBitmap, mDisplayWidth, mDisplayHeight);
  
      }
  
  
  
      public void startPlay() {
  
          thread = new Thread(this);
  
          thread.start(); 
  
      }
  
  
  
      @Override
  
      public void run() {
  
          while (true) {
  
              while (2 == mStatus) {
  
                  //pause
  
                  SystemClock.sleep(100);
  
              }
  
              mVideoCurrentFrame = naGetVideoFrame();
  
              if (0 < mVideoCurrentFrame) {
  
                  //success, redraw
  
                  if(isValid()){
  
                       Canvas canvas = lockCanvas(null);
  
                       if (null != mBitmap) {
  
                           canvas.drawBitmap(mBitmap, mDrawLeft, mDrawTop, prFramePaint);
  
                       }
  
                       unlockCanvasAndPost(canvas);
  
                  }
  
              } else {
  
                  //failure, probably end of video, break
  
                  naFinish(mBitmap);
  
                  mStatus = 0;
  
                  break;
  
              }
  
          }   
  
      }
  
  
  
  }

  In my MainActivity class, I instantiated this class in the following way :

  public void startCamera(int texture)
  
  {
  
      mSurface = new SurfaceTexture(texture);
  
      mSurface.setOnFrameAvailableListener(this); 
  
      Surface surface = new StreamingSurface(mSurface, 640, 360);
  
      surface.release();        
  
  }

  I read the following line in the Android developer page, regarding the Surface class constructor :

  "Images drawn to the Surface will be made available to the SurfaceTexture, which can attach them to an OpenGL ES texture via updateTexImage()."

  That is exactly what I want to do, and I have everything ready for the further renderization. But definitely, with the above code, I never get my frames captured in the surface class transformed to its corresponding SurfaceTexture. I know this because the debugger, for instace, never call the OnFrameAvailableLister method associated with that Surface Texture.

  Any ideas ? Maybe the fact that I am using a thread to call the drawing functions is messing everything ? In such a case, what alternatives I have to grab the frames ?

  Thanks in advance

• Subprocess call stopping asynchronously-executed Python parent process

  6 mai 2016, par Suriname0

  The following shell session demonstrates the behavior I am seeing :

  [user@compname python-test]$ cat test.py
  
  #!/usr/bin/env python
  
  import subprocess
  
  from time import sleep
  
  proc = subprocess.Popen("ffmpeg", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=True)
  
  print "Starting process: " + str(proc)
  
  status = proc.poll()
  
  while status is None:
  
      print "Process still running."
  
      sleep(0.01)
  
      status = proc.poll()
  
  print "Status: " + str(status)
  
  [user@compname python-test]$ python test.py
  
  Starting process: 
  
  Process still running.
  
  Process still running.
  
  Status: 1
  
  [user@compname python-test]$ python test.py &
  
  [4] 6976
  
  [user@compname python-test]$ Starting process: 
  
  Process still running.
  
  Process still running.
  
  [4]+  Stopped                 python test.py
  
  [user@compname python-test]$ ps
  
    PID TTY          TIME CMD
  
   4684 pts/101  00:00:00 python
  
   4685 pts/101  00:00:00 ffmpeg
  
   7183 pts/101  00:00:00 ps
  
  14385 pts/101  00:00:00 bash

  As you can see, when the simple test Python program is run normally, it completes successfully. When it is run asynchronously (using &), the Python process is stopped as soon as the subprocess call is complete (and poll() would return a non-None value).

  1. The same behavior occurs when using Popen.wait()
  2. The behavior is unique to ffmpeg.
  3. Both the Python process and ffmpeg are ending up stopped, as seen in the call to ps.

  Can someone help me detangle this behavior ? I don’t see anything in the documentation for the subprocess module, bash’s & operator, or ffmpeg that would explain this.

  The Python version is 2.6.6, bash is GNU bash version 4.1.2(1)-release (x86_64-redhat-linux-gnu), ffmpeg is version 3.0.1-static.

  Thank you for any help !