FfmpegController.java

package org.ffmpeg.android;


import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;


import org.ffmpeg.android.ShellUtils.ShellCallback;

import android.graphics.Bitmap;
import android.media.MediaMetadataRetriever;

public class FfmpegController {

	private File mFileBinDir;
	private String mFfmpegBin;
	
	private final static String TAG = "FFMPEG";
	
	private File mFileTemp;
	
	private String mCmdCat;
	
	public FfmpegController(File fileTemp, File fileAppRoot) throws FileNotFoundException, IOException {		
		mFileTemp = fileTemp;
		
		//mContext.getFilesDir().getParentFile()
		checkBinary (fileAppRoot);
		
	}
	
	private void checkBinary (File fileAppRoot) throws FileNotFoundException, IOException
	{
		mFileBinDir = new File(fileAppRoot,"lib");

		if (mFileBinDir.exists())
		{
			File fileBin = new File(mFileBinDir,"libffmpeg.so");

			if (fileBin.exists())
				mFfmpegBin = fileBin.getCanonicalPath();
			else
				mFfmpegBin = "ffmpeg";

		}
		else
		{
			mFfmpegBin = "ffmpeg";
		}
		
		mCmdCat = "sh cat";

	}
	
	private void execFFMPEG (List<String> cmd, ShellCallback sc, File fileExec) throws IOException, InterruptedException {
	
		String runtimeCmd = new File(mFileBinDir,"ffmpeg").getCanonicalPath();
		
		Runtime.getRuntime().exec("chmod 777 " +runtimeCmd);
    	
		execProcess (cmd, sc, fileExec);
	}
	
	private void execFFMPEG (List<String> cmd, ShellCallback sc) throws IOException, InterruptedException {
		execFFMPEG (cmd, sc, mFileBinDir);
	}
	
	private int execProcess(List<String> cmds, ShellCallback sc, File fileExec) throws IOException, InterruptedException {		
        
		//ensure that the arguments are in the correct Locale format
		for (String cmd :cmds)
		{
			cmd = String.format(Locale.US, "%s", cmd);
		}
		
		ProcessBuilder pb = new ProcessBuilder(cmds);
		pb.directory(fileExec);
		
		StringBuffer cmdlog = new StringBuffer();

		for (String cmd : cmds)
		{
			cmdlog.append(cmd);
			cmdlog.append(' ');
		}
		
		sc.shellOut(cmdlog.toString());
		
		//pb.redirectErrorStream(true);
		
		Process process = pb.start();    
    

		// any error message?
		StreamGobbler errorGobbler = new StreamGobbler(
				process.getErrorStream(), "ERROR", sc);

    	 // any output?
        StreamGobbler outputGobbler = new 
            StreamGobbler(process.getInputStream(), "OUTPUT", sc);

        errorGobbler.start();
        outputGobbler.start();

        int exitVal = process.waitFor();
        
        sc.processComplete(exitVal);
        
        return exitVal;
		
	}
	

	private int execProcess(String cmd, ShellCallback sc, File fileExec) throws IOException, InterruptedException {		
        
		//ensure that the argument is in the correct Locale format
		cmd = String.format(Locale.US, "%s", cmd);
		
		ProcessBuilder pb = new ProcessBuilder(cmd);
		pb.directory(fileExec);

	//	pb.redirectErrorStream(true);
    	Process process = pb.start();    
    	
    
    	  // any error message?
        StreamGobbler errorGobbler = new 
            StreamGobbler(process.getErrorStream(), "ERROR", sc);            
        
    	 // any output?
        StreamGobbler outputGobbler = new 
            StreamGobbler(process.getInputStream(), "OUTPUT", sc);
            
        // kick them off
        errorGobbler.start();
        outputGobbler.start();
     

        int exitVal = process.waitFor();
        
        sc.processComplete(exitVal);
        
        return exitVal;


		
	}
	
	
	public class Argument
	{
		String key;
		String value;
		
		public static final String VIDEOCODEC = "-vcodec";
		public static final String AUDIOCODEC = "-acodec";
		
		public static final String VIDEOBITSTREAMFILTER = "-vbsf";
		public static final String AUDIOBITSTREAMFILTER = "-absf";
		
		public static final String VERBOSITY = "-v";
		public static final String FILE_INPUT = "-i";
		public static final String SIZE = "-s";
		public static final String FRAMERATE = "-r";
		public static final String FORMAT = "-f";
		public static final String BITRATE_VIDEO = "-b:v";
		
		public static final String BITRATE_AUDIO = "-b:a";
		public static final String CHANNELS_AUDIO = "-ac";
		public static final String FREQ_AUDIO = "-ar";
		
		public static final String STARTTIME = "-ss";
		public static final String DURATION = "-t";
		
		
	}
	
	public void processVideo(Clip in, Clip out, boolean enableExperimental, ShellCallback sc) throws Exception {
		
    	ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		if (in.format != null)
		{
			cmd.add(Argument.FORMAT);
			cmd.add(in.format);
		}
	
		if (in.videoCodec != null)
		{
			cmd.add(Argument.VIDEOCODEC);
			cmd.add(in.videoCodec);
		}
		
		if (in.audioCodec != null)
		{
			cmd.add(Argument.AUDIOCODEC);
			cmd.add(in.audioCodec);
		}
		
		cmd.add("-i");
		cmd.add(new File(in.path).getCanonicalPath());
		
		if (out.videoBitrate > 0)
		{
			cmd.add(Argument.BITRATE_VIDEO);
			cmd.add(out.videoBitrate + "k");
		}
		
		if (out.width > 0)
		{
			cmd.add(Argument.SIZE);
			cmd.add(out.width + "x" + out.height);
		
		}
		if (out.videoFps != null)
		{
			cmd.add(Argument.FRAMERATE);
			cmd.add(out.videoFps);
		}
		
		if (out.videoCodec != null)
		{
			cmd.add(Argument.VIDEOCODEC);
			cmd.add(out.videoCodec);
		}
		
		if (out.videoBitStreamFilter != null)
		{
			cmd.add(Argument.VIDEOBITSTREAMFILTER);
			cmd.add(out.videoBitStreamFilter);
		}
		
		
		if (out.videoFilter != null)
		{
			cmd.add("-vf");
			cmd.add(out.videoFilter);
		}
		
		if (out.audioCodec != null)
		{
			cmd.add(Argument.AUDIOCODEC);
			cmd.add(out.audioCodec);
		}
		
		if (out.audioBitStreamFilter != null)
		{
			cmd.add(Argument.AUDIOBITSTREAMFILTER);
			cmd.add(out.audioBitStreamFilter);
		}
		if (out.audioChannels > 0)
		{
			cmd.add(Argument.CHANNELS_AUDIO);
			cmd.add(out.audioChannels+"");
		}
		
		if (out.audioBitrate > 0)
		{
			cmd.add(Argument.BITRATE_AUDIO);
			cmd.add(out.audioBitrate + "k");
		}
		
		if (out.format != null)
		{
			cmd.add("-f");
			cmd.add(out.format);
		}
		
		if (enableExperimental)
		{
			cmd.add("-strict");
			cmd.add("-2");//experimental
		}
		
		cmd.add(new File(out.path).getCanonicalPath());

		execFFMPEG(cmd, sc);
	    
	}
	
	
	public Clip createSlideshowFromImagesAndAudio (ArrayList<Clip> images, Clip audio,  Clip out, int durationPerSlide, ShellCallback sc) throws Exception
	{

		final String imageBasePath = new File(mFileTemp,"image-").getCanonicalPath();
		final String imageBaseVariablePath = imageBasePath + "%03d.jpg";
		
		
		ArrayList<String> cmd = new ArrayList<String>();
		
	
		String newImagePath = null;
		int imageCounter = 0;
		
		Clip imageCover = images.get(0); //add the first image twice
		
		cmd = new ArrayList<String>();
		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		cmd.add("-i");
		cmd.add(new File(imageCover.path).getCanonicalPath());
		
		if (out.width != -1 && out.height != -1)
		{
			cmd.add("-s");
			cmd.add(out.width + "x" + out.height);
		}
		
		newImagePath = imageBasePath + String.format(Locale.US, "%03d", imageCounter++) + ".jpg";
		cmd.add(newImagePath);
		
		execFFMPEG(cmd, sc);
		
		for (Clip image : images)
		{
			cmd = new ArrayList<String>();
			cmd.add(mFfmpegBin);
			cmd.add("-y");
			
			cmd.add("-i");
			cmd.add(new File(image.path).getCanonicalPath());
			
			if (out.width != -1 && out.height != -1)
			{
				cmd.add("-s");
				cmd.add(out.width + "x" + out.height);
			}
			
			newImagePath = imageBasePath + String.format(Locale.US, "%03d", imageCounter++) + ".jpg";
			cmd.add(newImagePath);
			
			execFFMPEG(cmd, sc);
			
			
		}
		
		//then combine them
		cmd = new ArrayList<String>();
		
		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		cmd.add("-loop");
		cmd.add("0");
		
		cmd.add("-f");
		cmd.add("image2");
		
		cmd.add("-r");
		cmd.add("1/" + durationPerSlide);
		
		cmd.add("-i");
		cmd.add(imageBaseVariablePath);
		
		cmd.add("-strict");
		cmd.add("-2");//experimental
	
		String fileTempMpg = new File(mFileTemp,"tmp.mpg").getCanonicalPath();
		
		cmd.add(fileTempMpg);
		
		execFFMPEG(cmd, sc);
		
		//now combine and encode
		cmd = new ArrayList<String>();
		
		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		cmd.add("-i");
		cmd.add(fileTempMpg);
		
		if (audio != null && audio.path != null)
		{
			cmd.add("-i");
			cmd.add(new File(audio.path).getCanonicalPath());
			
			cmd.add("-map");
			cmd.add("0:0");
			
			cmd.add("-map");
			cmd.add("1:0");
			
			cmd.add(Argument.AUDIOCODEC);
			cmd.add("aac");
			
			cmd.add(Argument.BITRATE_AUDIO);
			cmd.add("128k");
			
		}
		
		cmd.add("-strict");
		cmd.add("-2");//experimental
		
		cmd.add(Argument.VIDEOCODEC);
		

		if (out.videoCodec != null)
			cmd.add(out.videoCodec);
		else
			cmd.add("mpeg4");

		if (out.videoBitrate != -1)
		{
			cmd.add(Argument.BITRATE_VIDEO);
			cmd.add(out.videoBitrate + "k");
		}
		
		cmd.add(new File(out.path).getCanonicalPath());
		
		
		execFFMPEG(cmd, sc);
		
		return out;
	}
	
	/*
	 * ffmpeg -y -loop 0 -f image2 -r 0.5 -i image-%03d.jpg -s:v 1280x720 -b:v 1M \
   -i soundtrack.mp3 -t 01:05:00 -map 0:0 -map 1:0 out.avi
   
   -loop_input – loops the images. Disable this if you want to stop the encoding when all images are used or the soundtrack is finished.

-r 0.5 – sets the framerate to 0.5, which means that each image will be shown for 2 seconds. Just take the inverse, for example if you want each image to last for 3 seconds, set it to 0.33.

-i image-%03d.jpg – use these input files. %03d means that there will be three digit numbers for the images.

-s 1280x720 – sets the output frame size.

-b 1M – sets the bitrate. You want 500MB for one hour, which equals to 4000MBit in 3600 seconds, thus a bitrate of approximately 1MBit/s should be sufficient.

-i soundtrack.mp3 – use this soundtrack file. Can be any format.

-t 01:05:00 – set the output length in hh:mm:ss format.

out.avi – create this output file. Change it as you like, for example using another container like MP4.
	 */
	public Clip combineAudioAndVideo (Clip videoIn, Clip audioIn, Clip out, ShellCallback sc) throws Exception
	{
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");

		cmd.add("-i");
		cmd.add(new File(videoIn.path).getCanonicalPath());
		
		cmd.add("-i");
		cmd.add(new File(audioIn.path).getCanonicalPath());
		

		cmd.add("-strict");
		cmd.add("-2");//experimental
		
		cmd.add(Argument.AUDIOCODEC);
		if (out.audioCodec != null)
			cmd.add(out.audioCodec);
		else
		{
			cmd.add("copy");
			
		}

		cmd.add(Argument.VIDEOCODEC);
		if (out.videoCodec != null)
			cmd.add(out.videoCodec);
		else
		{
			cmd.add("copy");
		}
		
		if (out.videoBitrate != -1)
		{
			cmd.add(Argument.BITRATE_VIDEO);
			cmd.add(out.videoBitrate + "k");
		}
		
		if (out.videoFps != null)
		{
			cmd.add(Argument.FRAMERATE);
			cmd.add(out.videoFps);
		}
		
		if (out.audioBitrate != -1)
		{
			cmd.add(Argument.BITRATE_AUDIO);
			cmd.add(out.audioBitrate + "k");
		}
		cmd.add("-y");
		
		cmd.add("-cutoff");
		cmd.add("15000");
		
		if (out.width > 0)
		{
			cmd.add(Argument.SIZE);
			cmd.add(out.width + "x" + out.height);
		
		}
		
		if (out.format != null)
		{
			cmd.add("-f");
			cmd.add(out.format);
		}

		File fileOut = new File(out.path);
		cmd.add(fileOut.getCanonicalPath());
		
		execFFMPEG(cmd, sc);
		
		
		return out;
		
	}
	
	public Clip convertImageToMP4 (Clip mediaIn, int duration, String outPath, ShellCallback sc) throws Exception
	{
		Clip result = new Clip ();
		ArrayList<String> cmd = new ArrayList<String>();

		// ffmpeg -loop 1 -i IMG_1338.jpg -t 10 -r 29.97 -s 640x480 -qscale 5 test.mp4
		
		cmd = new ArrayList<String>();
		
		//convert images to MP4
		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		cmd.add("-loop");
		cmd.add("1");
		
		cmd.add("-i");
		cmd.add(new File(mediaIn.path).getCanonicalPath());
		
		cmd.add(Argument.FRAMERATE);
		cmd.add(mediaIn.videoFps);
		
		cmd.add("-t");
		cmd.add(duration + "");
		
		cmd.add("-qscale");
		cmd.add("5"); //a good value 1 is best 30 is worst
		
		if (mediaIn.width != -1)
		{
			cmd.add(Argument.SIZE);
			cmd.add(mediaIn.width + "x" + mediaIn.height);
		//	cmd.add("-vf");
		//	cmd.add("\"scale=-1:" + mediaIn.width + "\"");
		}
		
		if (mediaIn.videoBitrate != -1)
		{
			cmd.add(Argument.BITRATE_VIDEO);
			cmd.add(mediaIn.videoBitrate + "");
		}
		
	
	//	-ar 44100 -acodec pcm_s16le -f s16le -ac 2 -i /dev/zero -acodec aac -ab 128k \ 
	//	-map 0:0 -map 1:0
		
		result.path = outPath;
		result.videoBitrate = mediaIn.videoBitrate;
		result.videoFps = mediaIn.videoFps;
		result.mimeType = "video/mp4";

		cmd.add(new File(result.path).getCanonicalPath());
		
		execFFMPEG(cmd, sc);
		
		return result;
	}
	
	//based on this gist: https://gist.github.com/3757344
	//ffmpeg -i input1.mp4 -vcodec copy -vbsf h264_mp4toannexb -acodec copy part1.ts
	//ffmpeg -i input2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts intermediate2.ts

	public Clip convertToMP4Stream (Clip mediaIn, String startTime, double duration, String outPath, ShellCallback sc) throws Exception
	{ 
		ArrayList<String> cmd = new ArrayList<String>();

		Clip mediaOut = new Clip();
		mediaOut.path = outPath;
		
		String mediaPath = new File(mediaIn.path).getCanonicalPath();
		
		cmd = new ArrayList<String>();
		
		cmd.add(mFfmpegBin);
		cmd.add("-y");

		if (startTime != null)
		{
			cmd.add(Argument.STARTTIME);
			cmd.add(startTime);
		}
		
		if (duration != -1)
		{
			cmd.add(Argument.DURATION);
			
			double dValue = mediaIn.duration;
			int hours = (int)(dValue/3600f);
			dValue -= (hours*3600);
			
			cmd.add("0");
			cmd.add(String.format(Locale.US,"%s",hours));
			cmd.add(":");
			
			int min = (int)(dValue/60f);
			dValue -= (min*60);
			
			cmd.add("0");
			cmd.add(String.format(Locale.US,"%s",min));
			cmd.add(":");
			
			cmd.add(String.format(Locale.US,"%f",dValue));
			
			//cmd.add("00:00:" + String.format(Locale.US,"%f",mediaIn.duration));
			
			
		}
		
		cmd.add("-i");
		cmd.add(mediaPath);
		
		cmd.add("-f");
		cmd.add("mpegts");
		
		cmd.add("-c");
		cmd.add("copy");
		
		cmd.add("-an");
		
		//cmd.add(Argument.VIDEOBITSTREAMFILTER);
		cmd.add("-bsf:v");
		cmd.add("h264_mp4toannexb");
		
		File fileOut = new File(mediaOut.path);
		mediaOut.path = fileOut.getCanonicalPath();
		
		cmd.add(mediaOut.path);

		execFFMPEG(cmd, sc);
		
		return mediaOut;
	}
	
	
	public Clip convertToWaveAudio (Clip mediaIn, String outPath, int sampleRate, int channels, ShellCallback sc) throws Exception
	{
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		
		if (mediaIn.startTime != null)
		{
			cmd.add("-ss");
			cmd.add(mediaIn.startTime);
		}
		
		if (mediaIn.duration != -1)
		{
			cmd.add("-t");
			cmd.add(String.format(Locale.US,"%f",mediaIn.duration));
		}
		
		cmd.add("-i");
		cmd.add(new File(mediaIn.path).getCanonicalPath());
		
		
		cmd.add("-ar");
		cmd.add(sampleRate + "");
		
		cmd.add("-ac");
		cmd.add(channels + "");
		
		cmd.add("-vn");
		
		Clip mediaOut = new Clip();
		
		File fileOut = new File(outPath);
		mediaOut.path = fileOut.getCanonicalPath();
		
		cmd.add(mediaOut.path);

		execFFMPEG(cmd, sc);
		
		return mediaOut;
	}
	
	public Clip convertTo3GPAudio (Clip mediaIn, Clip mediaOut, ShellCallback sc) throws Exception
	{
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		cmd.add("-i");
		cmd.add(new File(mediaIn.path).getCanonicalPath());
		
		if (mediaIn.startTime != null)
		{
			cmd.add("-ss");
			cmd.add(mediaIn.startTime);
		}
		
		if (mediaIn.duration != -1)
		{
			cmd.add("-t");
			cmd.add(String.format(Locale.US,"%f",mediaIn.duration));

		}
		
		cmd.add("-vn");
		
		if (mediaOut.audioCodec != null)
		{
			cmd.add("-acodec");
			cmd.add(mediaOut.audioCodec);
		}
		
		if (mediaOut.audioBitrate != -1)
		{
			cmd.add("-ab");
			cmd.add(mediaOut.audioBitrate + "k");
		}
		
		cmd.add("-strict");
		cmd.add("-2");

		File fileOut = new File(mediaOut.path);
		
		cmd.add(fileOut.getCanonicalPath());

		execFFMPEG(cmd, sc);
		
		return mediaOut;
	}
	
	public Clip convert (Clip mediaIn, String outPath, ShellCallback sc) throws Exception
	{
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		cmd.add("-i");
		cmd.add(new File(mediaIn.path).getCanonicalPath());
		
		if (mediaIn.startTime != null)
		{
			cmd.add("-ss");
			cmd.add(mediaIn.startTime);
		}
		
		if (mediaIn.duration != -1)
		{
			cmd.add("-t");
			cmd.add(String.format(Locale.US,"%f",mediaIn.duration));

		}
		
		
		Clip mediaOut = new Clip();
		

		File fileOut = new File(outPath);
		 
		mediaOut.path = fileOut.getCanonicalPath();
		
		cmd.add(mediaOut.path);

		execFFMPEG(cmd, sc);
		
		return mediaOut;
	}
	
	public Clip convertToMPEG (Clip mediaIn, String outPath, ShellCallback sc) throws Exception
	{
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		cmd.add("-i");
		cmd.add(new File(mediaIn.path).getCanonicalPath());
		
		if (mediaIn.startTime != null)
		{
			cmd.add("-ss");
			cmd.add(mediaIn.startTime);
		}
		
		if (mediaIn.duration != -1)
		{
			cmd.add("-t");
			cmd.add(String.format(Locale.US,"%f",mediaIn.duration));

		}
		

		//cmd.add("-strict");
		//cmd.add("experimental");
		
		//everything to mpeg
		cmd.add("-f");
		cmd.add("mpeg");
		
		Clip mediaOut = mediaIn.clone();
		
		File fileOut = new File(outPath);
		
		mediaOut.path = fileOut.getCanonicalPath();
		
		cmd.add(mediaOut.path);

		execFFMPEG(cmd, sc);
		
		return mediaOut;
	}
	
	public void concatAndTrimFilesMPEG (ArrayList<Clip> videos,Clip out, boolean preConvert, ShellCallback sc) throws Exception
	{
    	
		int idx = 0;
		
		if (preConvert)
		{
			for (Clip mdesc : videos)
			{
				if (mdesc.path == null)
					continue;
			
				//extract MPG video
				ArrayList<String> cmd = new ArrayList<String>();
	
				cmd.add(mFfmpegBin);
				cmd.add("-y");
				cmd.add("-i");
				cmd.add(mdesc.path);
				
				if (mdesc.startTime != null)
				{
					cmd.add("-ss");
					cmd.add(mdesc.startTime);
				}
				
				if (mdesc.duration != -1)
				{
					cmd.add("-t");
					cmd.add(String.format(Locale.US,"%f",mdesc.duration));

				}
				
				/*
				cmd.add ("-acodec");
				cmd.add("pcm_s16le");
				
				cmd.add ("-vcodec");
				cmd.add("mpeg2video");
				*/
				
				if (out.audioCodec == null)
					cmd.add("-an"); //no audio
	
				//cmd.add("-strict");
				//cmd.add("experimental");
				
				//everything to mpeg
				cmd.add("-f");
				cmd.add("mpeg");
				cmd.add(out.path + '.' + idx + ".mpg");
	
				execFFMPEG(cmd, sc);
	
				idx++;
			}
		}
		
		StringBuffer cmdRun = new StringBuffer();
		
		cmdRun.append(mCmdCat);
		
		idx = 0;
		
		for (Clip vdesc : videos)
		{
			if (vdesc.path == null)
				continue;
	
			if (preConvert)
				cmdRun.append(out.path).append('.').append(idx++).append(".mpg").append(' '); //leave a space at the end!
			else
				cmdRun.append(vdesc.path).append(' ');
		}
		
		String mCatPath = out.path + ".full.mpg";
		
		cmdRun.append("> ");
		cmdRun.append(mCatPath);
		
		String[] cmds = {"sh","-c",cmdRun.toString()};
		Runtime.getRuntime().exec(cmds).waitFor();
		
		
		Clip mInCat = new Clip();
		mInCat.path = mCatPath;
		
		processVideo(mInCat, out, false, sc);
		
		out.path = mCatPath;
	}
	
	public void extractAudio (Clip mdesc, String audioFormat, File audioOutPath, ShellCallback sc) throws IOException, InterruptedException 
	{
		
		//no just extract the audio
		ArrayList<String> cmd = new ArrayList<String>();

		cmd.add(mFfmpegBin);
		cmd.add("-y");
		cmd.add("-i");
		cmd.add(new File(mdesc.path).getCanonicalPath());
		
		cmd.add("-vn");
		
		if (mdesc.startTime != null)
		{
			cmd.add("-ss");
			cmd.add(mdesc.startTime);
		}
		
		if (mdesc.duration != -1)
		{
			cmd.add("-t");
			cmd.add(String.format(Locale.US,"%f",mdesc.duration));

		}
					
		cmd.add("-f");
		cmd.add(audioFormat); //wav
		
		//everything to WAV!
		cmd.add(audioOutPath.getCanonicalPath());

		execFFMPEG(cmd, sc);
		
	}
	
	private class FileMover {

		InputStream inputStream;
		File destination;
		
		public FileMover(InputStream _inputStream, File _destination) {
			inputStream = _inputStream;
			destination = _destination;
		}
		
		public void moveIt() throws IOException {
		
			OutputStream destinationOut = new BufferedOutputStream(new FileOutputStream(destination));
				
			int numRead;
			byte[] buf = new byte[1024];
			while ((numRead = inputStream.read(buf) ) >= 0) {
				destinationOut.write(buf, 0, numRead);
			}
			    
			destinationOut.flush();
			destinationOut.close();
		}
	}
	
	public int killVideoProcessor (boolean asRoot, boolean waitFor) throws IOException
	{
		int killDelayMs = 300;

		int result = -1;
		
		int procId = -1;
		
		while ((procId = ShellUtils.findProcessId(mFfmpegBin)) != -1)
		{
			
		//	Log.d(TAG, "Found PID=" + procId + " - killing now...");