Recherche avancée

Sur d’autres sites (6866)

• 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.

• (ffmpeg.autogen)How can i Decode Audio AVframe (rtsp)

  2 octobre 2018, par newbie

  i Got Audio stream Frame.

  this code....

  while ((error = ffmpeg.av_read_frame(_pFormatContext, _pPacket)) == 0)
  

  if (error == ffmpeg.AVERROR_EOF)
  
  {
  
      frame = *_vFrame;
  
  }
  
  
  
  if (_pPacket->stream_index == _v_streamIndex)
  
  {
  
      ffmpeg.avcodec_send_packet(_vCodecContext, _pPacket).ThrowExceptionIfError();
  
      error = ffmpeg.avcodec_receive_frame(_vCodecContext, _vFrame);
  
  
  
      frame = *_vFrame;
  
  
  
      vFrame_Recv.Invoke(this, frame);
  
  }
  
  else if (_pPacket->stream_index == _a_streamIndex)
  
  {
  
      ffmpeg.avcodec_send_packet(_aCodecContext, _pPacket).ThrowExceptionIfError();
  
      error = ffmpeg.avcodec_receive_frame(_aCodecContext, _aFrame);
  
  
  
      frame = *_vFrame;
  
  
  
      aFrame_Recv.Invoke(this, frame);
  
  }
  
  
  
  ffmpeg.av_packet_unref(_pPacket);
  
  
  
  error.ThrowExceptionIfError();

  and i try Convert This Code.

  private void Vsd_aFrame_Recv(object sender, AVFrame frame)
  
  {
  
      //throw new NotImplementedException();
  
  }
  
  
  
  private unsafe void Vsd_vFrame_Recv(object sender, AVFrame frame)
  
  {
  
      var convertedFrame = vfc.Convert(frame);
  
  
  
      using (var bitmap = new Bitmap(convertedFrame.width, convertedFrame.height, convertedFrame.linesize[0], PixelFormat.Format24bppRgb, (IntPtr)convertedFrame.data[0]))
  
          BitmapReceived?.Invoke(this, new Bitmap(bitmap));
  
  }

  how can i decode Audio Frame...??
  i want play Audio.

• Piping ffmpeg thumbail output to another program

  21 septembre 2018, par Ryan Griggs

  I’m trying to capture frames from a live video stream (h.264) and pipe the resulting JPG images to a Node JS script, instead of saving these individual frames directly to .jpg files.

  As a test, I created the following Node JS script, to simply capture the incoming piped data, then dump it to a file :

  // pipe.js - test pipe output
  
  var fs = require('fs');
  
  var data = '';
  
  
  
  process.stdin.resume();
  
  process.stdin.setEncoding('utf8');
  
  
  
  var filename = process.argv[2];
  
  
  
  process.stdin.on('data', (chunk) => {
  
          console.log('Received data chunk via pipe.');
  
          data += chunk;
  
  });
  
  
  
  process.stdin.on('end', () => {
  
          console.log('Data ended.');
  
          fs.writeFile(filename, data, err => {
  
                  if (err) {
  
                          console.log('Error writing file: error #', err);
  
                  }
  
          });
  
          console.log('Saved file.');
  
  });
  
  
  
  console.log('Started...  Filename = ' + filename);

  Here’s the ffmpeg command I used :

  ffmpeg -vcodec h264_mmal -i "rtsp://[stream url]" -vframes 1 -f image2pipe - | node pipe.js test.jpg

  This generated the following output, and also produced a 175kB file which contains garbage (unreadable as a jpg file anyway). FYI using ffmpeg to export directly to a jpg file produced files around 25kB in size.

  ...
  
  Press [q] to stop, [?] for help
  
  [h264_mmal @ 0x130d3f0] Changing output format.
  
  Input stream #0:0 frame changed from size:1280x720 fmt:yuvj420p to size:1280x720 fmt:yuv420p
  
  [swscaler @ 0x1450ca0] deprecated pixel format used, make sure you did set range correctly
  
  Received data chunk via pipe.
  
  Received data chunk via pipe.
  
  frame=    1 fps=0.0 q=7.7 Lsize=      94kB time=00:00:00.40 bitrate=1929.0kbits/s speed=1.18x
  
  video:94kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.000000%
  
  Received data chunk via pipe.
  
  Data ended.
  
  Saved file.

  You can see that the Node JS script is receiving piped data (per the "Received data via pipe" messages above. However, it doesn’t seem to be outputting a valid JPG file. I can’t find a way to specifically request that ffmpeg output JPG format, since there is no -vcodec option for JPG. I tried using -vcodec png and outputting to a .png file, but the resulting file was about 2MB in size and also unreadable as a png file.

  Is this a problem caused by using utf8 encoding, or am I doing something else wrong ?

  Thanks for any advice.

  UPDATE : OK I got it to send a single jpg image correctly. The issue was in the way Node JS was capturing the stream data. Here’s a working script :

  // pipe.js - capture piped binary input and write to file
  
  var fs = require('fs');
  
  var filename = process.argv[2];
  
  
  
  console.log("Opening " + filename + " for binary writing...");
  
  
  
  var wstream = fs.createWriteStream(filename);
  
  
  
  process.stdin.on('readable', () => {
  
          var chunk = '';
  
          while ((chunk = process.stdin.read()) !== null) {
  
                  wstream.write(chunk);   // Write the binary data to file
  
                  console.log("Writing chunk to file...");
  
          }
  
  });
  
  
  
  process.stdin.on('end', () => {
  
          // Close the file
  
          wstream.end();
  
  });

  However, now the problem is this : when piping the output of ffmpeg to this script, how can I tell when one JPG file ends and another one begins ?

  ffmpeg command :

   ffmpeg -vcodec h264_mmal -i "[my rtsp stream]" -r 1 -q:v 2 -f singlejpeg - | node pipe.js test_output.jpg

  The test_output.jpg file continues to grow as long as the script runs. How can I instead know when the data for one jpg is complete and another one has started ?
  According to this, jpeg files always start with FF D8 FF and end with FF D9, so I guess I can check for this ending signature and start a new file at that point... any other suggestions ?