Recherche avancée

Sur d’autres sites (4168)

• Get total duration of multiple video files ? [duplicate]

  16 novembre 2018, par Soyal7

  This question already has an answer here :

  • Get duration from multiple video files ?
    
    2 answers
    
  • ffprobe Fastest way to read video packets
    
    1 answer
    

  I want to extract video duration metadata from every video file in a specified directory and then sum all and view the total time in desktop app.

  I need to extract data from as much as hundreds of videos overall. In Windows I can view the total duration for many files manually when selecting them in the explorer and going into details. For 1500 mp4 files it takes about 20 seconds to make the calculations and view the total time. It’s much faster then what I’m currently getting when iterating with FFprobe.

  for filename in dirFiles:
  
     print(subprocess.check_output(['ffprobe', '-i', filename, '-show_entries','format=duration', '-sexagesimal' ,'-v', 'quiet', '-of', 'csv=%s' % ("p=0")]))

  What is the faster way to do this ?

• Get total time/progress from multiple FFmpeg terminal commands

  24 septembre 2018, par kataroty

  I have a class that executes multiple FFmpeg commands in Android. The problem is that I have no idea how to get total time and then update the progress as the commands run.

  Since there are so many I am not even sure if it is possible.

  So hence my question : Is it possible to get total time/progress or at least estimated time/progress and then update it onProgress.

  And here is my class :

  public class AudioProcessor {
  
  
  
      private Context context;
  
      private FFmpeg ffmpeg;
  
      private AudioProcessorListener listener;
  
  
  
      private File micPcmFile;
  
      private File backgroundMp3File;
  
  
  
      private File pcmtowavTempFile;
  
      private File mp3towavTempFile;
  
      private File combinedwavTempFile;
  
  
  
      private File outputFile;
  
      private File volumeChangedTempFile;
  
  
  
  
  
      public AudioProcessor(Context context) {
  
          ffmpeg = FFmpeg.getInstance(context);
  
          this.context = context;
  
      }
  
  
  
      /**
  
       * Program main method. Starts running program
  
       * @throws Exception
  
       */
  
      public void process() throws Exception {
  
          if (!ffmpeg.isSupported()) {
  
              Log.e("AudioProcessor", "FFMPEG not supported! Cannot convert audio!");
  
              throw new Exception("FFMPeg has to be supported");
  
          }
  
          if (!checkIfAllFilesPresent()) {
  
              Log.e("AudioProcessor", "All files are not set yet. Please set file first");
  
              throw new Exception("Files are not set!");
  
          }
  
          listener.onStart();
  
          prepare();
  
          convertPCMToWav();
  
      }
  
  
  
      /**
  
       * Prepares program
  
       */
  
      private void prepare() {
  
          prepareTempFiles();
  
      }
  
  
  
      /**
  
       * Converts PCM to wav file. Automatically create new file.
  
       */
  
      private void convertPCMToWav() {
  
          System.out.println("AudioProcessor: Convert PCM TO Wav");
  
          //ffmpeg -f s16le -ar 44.1k -ac 2 -i file.pcm file.wav
  
          String[] cmd = { "-f" , "s16le", "-ar", "44.1k",  "-i", micPcmFile.toString(), pcmtowavTempFile.toString()};
  
          ffmpeg.execute(cmd, new ExecuteBinaryResponseHandler() {
  
              @Override
  
              public void onSuccess(String message) {
  
                  super.onSuccess(message);
  
                  convertMP3ToWav();
  
              }
  
              @Override
  
              public void onFailure(String message) {
  
                  super.onFailure(message);
  
                  onError(message);
  
              }
  
          });
  
      }
  
  
  
      /**
  
       * Converts mp3 file to wav file.
  
       * Automatically creates Wav file
  
       */
  
      private void convertMP3ToWav() {
  
          //ffmpeg -i file.mp3 file.wav
  
          String[] cmd = { "-i" , backgroundMp3File.toString(), mp3towavTempFile.toString() };
  
          ffmpeg.execute(cmd, new ExecuteBinaryResponseHandler() {
  
              @Override
  
              public void onSuccess(String message) {
  
                  super.onSuccess(message);
  
                  changeMicAudio();
  
              }
  
              @Override
  
              public void onFailure(String message) {
  
                  super.onFailure(message);
  
                  onError(message);
  
              }
  
          });
  
      }
  
  
  
      /**
  
       * Combines 2 wav files into one wav file. Overlays audio
  
       */
  
      private void combineWavs() {
  
          //ffmpeg -i C:\Users\VR1\Desktop\_mp3.wav -i C:\Users\VR1\Desktop\_pcm.wav -filter_complex amix=inputs=2:duration=first:dropout_transition=3 C:\Users\VR1\Desktop\out.wav
  
  
  
          String[] cmd = { "-i" , pcmtowavTempFile.toString(), "-i", volumeChangedTempFile.toString(), "-filter_complex", "amix=inputs=2:duration=first:dropout_transition=3", combinedwavTempFile.toString()};
  
          ffmpeg.execute(cmd, new ExecuteBinaryResponseHandler() {
  
  
  
              @Override
  
              public void onSuccess(String message) {
  
                  super.onSuccess(message);
  
                  encodeWavToAAC();
  
              }
  
              @Override
  
              public void onFailure(String message) {
  
                  super.onFailure(message);
  
                  onError(message);
  
              }
  
          });
  
      }
  
  
  
      private void changeMicAudio(){
  
          //ffmpeg -i input.wav -filter:a "volume=1.5" output.wav
  
  
  
          String[] cmdy = { "-i", mp3towavTempFile.toString(),  "-af", "volume=0.9", volumeChangedTempFile.toString()};
  
          ffmpeg.execute(cmdy, new ExecuteBinaryResponseHandler() {
  
  
  
              @Override
  
              public void onSuccess(String message) {
  
                  combineWavs();
  
                  super.onSuccess(message);
  
              }
  
              @Override
  
              public void onFailure(String message) {
  
                  super.onFailure(message);
  
  
  
              }
  
          });
  
      }
  
  
  
  
  
      /**
  
       * Do something on error. Releases program data (deletes files)
  
       * @param message
  
       */
  
      private void onError(String message) {
  
          release();
  
          if (listener != null) {
  
              listener.onError(message);
  
          }
  
      }
  
      /**
  
       * Encode to AAC
  
       */
  
      private void encodeWavToAAC() {
  
          //ffmpeg -i file.wav -c:a aac -b:a 128k -f adts output.m4a
  
          String[] cmd = { "-i" , combinedwavTempFile.toString(), "-c:a", "aac", "-b:a", "128k", "-f", "adts", outputFile.toString()};
  
          ffmpeg.execute(cmd, new ExecuteBinaryResponseHandler() {
  
  
  
              @Override
  
              public void onSuccess(String message) {
  
                  super.onSuccess(message);
  
                  if (listener != null) {
  
                      listener.onSuccess(outputFile);
  
                  }
  
                  release();
  
              }
  
              @Override
  
              public void onFailure(String message) {
  
                  super.onFailure(message);
  
                  onError(message);
  
              }
  
          });
  
      }
  
  
  
      /**
  
       * Uninitializes class
  
       */
  
      private void release() {
  
          if (listener != null) {
  
              listener.onFinish();
  
          }
  
          destroyTempFiles();
  
      }
  
  
  
      /**
  
       * Prepares temp required files by deleteing them if they exsist.
  
       * Files cannot exists before ffmpeg actions. FFMpeg automatically creates those files.
  
       */
  
      private void prepareTempFiles() {
  
          pcmtowavTempFile = new File(context.getFilesDir()+ Common.TEMP_LOCAL_DIR + "/" + "_pcm.wav");
  
          mp3towavTempFile = new File(context.getFilesDir()+ Common.TEMP_LOCAL_DIR + "/" + "_mp3.wav");
  
          combinedwavTempFile = new File(context.getFilesDir()+ Common.TEMP_LOCAL_DIR + "/" + "_combined.wav");
  
          volumeChangedTempFile = new File(context.getFilesDir()+ Common.TEMP_LOCAL_DIR + "/" + "_volumeChanged.wav");
  
  
  
          if (pcmtowavTempFile.exists()) {
  
              destroyTempFiles();
  
          }
  
      }
  
  
  
      /**
  
       * Destroys temp required files
  
       */
  
      private void destroyTempFiles() {
  
          pcmtowavTempFile.delete();
  
          mp3towavTempFile.delete();
  
          combinedwavTempFile.delete();
  
          volumeChangedTempFile.delete();
  
      }
  
  
  
      /**
  
       * Checks if all files are set, so we can process them
  
       * @return - all files ready
  
       */
  
      private boolean checkIfAllFilesPresent() {
  
          if(micPcmFile == null || backgroundMp3File == null || outputFile == null) {
  
              Log.e("AudioProcessor", "All files are not set! Set all files!");
  
              return false;
  
          }
  
          return true;
  
      }
  
  
  
      public void setOutputFile(File outputFile) {
  
          this.outputFile = outputFile;
  
      }
  
  
  
      public void setListener(AudioProcessorListener listener) {
  
          this.listener = listener;
  
      }
  
  
  
      public void setMicPcmFile(File micPcmFile) {
  
  
  
  
  
          this.micPcmFile = micPcmFile;
  
      }
  
  
  
      public void setBackgroundMp3File(File backgroundMp3File) {
  
          this.backgroundMp3File = backgroundMp3File;
  
      }
  
  
  
  
  
      public interface AudioProcessorListener {
  
          void onStart();
  
          void onSuccess(File output);
  
          void onError(String message);
  
          void onFinish();
  
      }
  
  }

  Since the whole thing is taking a long time, if someone can recommend something that would take less time, then it would also help. A 2 minute video usually takes like 50s.

• Get Total number of frames and FPS faster than with OpenCV library in C++

  20 juillet 2018, par daniels_pa

  I need to check which video can be analyzed and which cannot given the total number of frames in a video and the fps of the video. I created a c++ program to do the checking. Analyzing each video is not an option since analyzing is time consuming.

  I used the OpenCV library for starters :

      cv::VideoCapture vid_to_analyze;
  
      vid_to_analyze.open( me_vid.vid_path.string() );
  
      me_vid.total_frames= static_cast<int>(vid_to_analyze.get(CV_CAP_PROP_FRAME_COUNT));
  
      me_vid.fps=vid_to_analyze.get(CV_CAP_PROP_FPS);
  
  
  
      if (!vid_to_analyze.isOpened())
  
      {
  
          std::cout &lt;&lt; "Skipping vid: "&lt;&lt; me_vid.vid_path.string()&lt;&lt;", couldn't open it" &lt;&lt; std::endl;
  
      }
  
      if (me_vid.fps != me_vid.fps || me_vid.fps &lt;= 0)
  
      {
  
          std::cout &lt;&lt; "For video " &lt;&lt; me_vid.vid_path.string() &lt;&lt; std::endl;
  
          std::cout &lt;&lt; "FPS of the video file cannot be determined, assuming 30"&lt;&lt; std::endl;
  
          me_vid.fps = 30;
  
      }
  
  
  
      vid_to_analyze.release();
  
  </int>

  However when debugging it becomes painfully slow (the program is faster running without the debugger attached but still very slow given the number of videos it needs to cover). I think that has something to do with 4 threads being created and deleted each time a video is opened (released).

  How to get total number of frames and fps in a faster manner ( without actually creating 4 threads !!) if i am not interested in actually grabbing frames from the video just the number of frames and fps.

  Is there a way to use ffmpeg library from c++, would that be faster and where to start ?

  EDIT : Valgrind seems to agree since (Ir=)91.66% of time spend in the vid_to_analyze.open phase