java封装FFmpeg命令，支持原生ffmpeg全部命令，实现FFmpeg多进程处理与多线程输出控制(开启、关闭、查询)，rtsp/rtmp推流、拉流

前言：

之前已经对FFmpeg命令进行了封装http://blog.csdn.net/eguid_1/article/details/51787646，但是当时没有考虑到扩展性，所以总体设计不是太好，需要改动的地方也比较多，也不支持原生ffmpeg命令，所以本次版本推翻了前面的版本重新设计接口和实现，全面支持各个流程注入自己的实现，并且在原有命令组装基础上增加一个接口用来支持全部原生FFmpeg命令。

概述：

提供一个管理器用于方便管理FFmpeg命令的执行、停止和执行信息持久化。

可以方便的使用ffmpeg来进行推流，拉流，转流等任务

实现的功能：

①开启一个进程+一个输出线程来执行原生ffmpeg命令②开启一个进程+一个输出线程来执行组装命令③查询执行任务信息④查询全部正在执行的任务⑤停止进程和输出线程⑥停止全部正在执行的任务

源码包下载：http://download.csdn.net/detail/eguid_1/9668143

github项目地址：https://github.com/eguid/FFmpegCommandHandler4java

1、接口设计

1.1、发布任务接口
通过原生ffmpeg命令发布处理任务
通过map组装成ffmpeg命令来处理任务
1.2、终止任务接口
结束任务
结束全部任务
1.3、任务查询接口
查询
查询全部

1.4、接口实现注入

执行处理器注入

命令组装器注入

持久化实现注入

2、内部实现

2.1、任务处理器
开启一个进程用于执行ffmpeg命令
开启一个子线程用于输出ffmpeg执行过程
停止进程
停止输出线程（需要在进程关闭前停止输出线程）
按照正确顺序停止进程和线程2.2、输出线程处理器
用于输出ffmpeg执行过程

[java] view plain copy

1. package cc.eguid.FFmpegCommandManager.service;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.io.InputStreamReader;  
7.   
8. import cc.eguid.FFmpegCommandManager.entity.TaskEntity;  
9. /** 
10.  * 任务处理实现 
11.  * @author eguid 
12.  * @since jdk1.7 
13.  * @version 2016年10月29日 
14.  */  
15. public class TaskHandlerImpl implements TaskHandler {  
16.     private Runtime runtime = null;  
17.   
18.     @Override  
19.     public TaskEntity process(String id, String command) {  
20.         Process process = null;  
21.         OutHandler outHandler = null;  
22.         TaskEntity tasker = null;  
23.         try {  
24.             if (runtime == null) {  
25.                 runtime = Runtime.getRuntime();  
26.             }  
27.             process = runtime.exec(command);// 执行本地命令获取任务主进程  
28.             outHandler = new OutHandler(process.getErrorStream(), id);  
29.             outHandler.start();  
30.             tasker = new TaskEntity(id, process, outHandler);  
31.         } catch (IOException e) {  
32.             stop(outHandler);  
33.             stop(process);  
34.             // 出现异常说明开启失败，返回null  
35.             return null;  
36.         }  
37.         return tasker;  
38.     }  
39.   
40.     @Override  
41.     public boolean stop(Process process) {  
42.         if (process != null && process.isAlive()) {  
43.             process.destroy();  
44.             return true;  
45.         }  
46.         return false;  
47.     }  
48.   
49.     @Override  
50.     public boolean stop(Thread outHandler) {  
51.         if (outHandler != null && outHandler.isAlive()) {  
52.             outHandler.stop();  
53.             outHandler.destroy();  
54.             return true;  
55.         }  
56.         return false;  
57.     }  
58.   
59.     @Override  
60.     public boolean stop(Process process, Thread thread) {  
61.         boolean ret;  
62.         ret=stop(thread);  
63.         ret=stop(process);  
64.         return ret;  
65.     }  
66. }  
67.   
68. /** 
69.  *  
70.  * @author eguid 
71.  * 
72.  */  
73. class OutHandler extends Thread {  
74.     /** 
75.      * 控制状态 
76.      */  
77.     private volatile boolean desstatus = true;  
78.   
79.     /** 
80.      * 读取输出流 
81.      */  
82.     private BufferedReader br = null;  
83.   
84.     /** 
85.      * 输出类型 
86.      */  
87.     private String type = null;  
88.   
89.     public OutHandler(InputStream is, String type) {  
90.         br = new BufferedReader(new InputStreamReader(is));  
91.         this.type = type;  
92.     }  
93.   
94.     /** 
95.      * 重写线程销毁方法，安全的关闭线程 
96.      */  
97.     @Override  
98.     public void destroy() {  
99.         setDesStatus(false);  
100.     }  
101.   
102.     public void setDesStatus(boolean desStatus) {  
103.         this.desstatus = desStatus;  
104.     }  
105.   
106.     /** 
107.      * 执行输出线程 
108.      */  
109.     @Override  
110.     public void run() {  
111.         String msg = null;  
112.         int index = 0;  
113.         int errorIndex = 0;  
114.         int status = 10;  
115.         try {  
116.             System.out.println(type + "开始推流！");  
117.             while (desstatus && (msg = br.readLine()) != null) {  
118.                 if (msg.indexOf("[rtsp") != -1) {  
119.                     System.out.println("接收" + status + "个数据包" + msg);  
120.                     System.out.println(type + "，网络异常丢包，丢包次数:" + errorIndex++ + "，消息体：" + msg);  
121.                     status = 10;  
122.                     index = 0;  
123.                 }  
124.   
125.                 if (index % status == 0) {  
126.                     System.out.println("接收" + status + "个数据包" + msg);  
127.                     status *= 2;  
128.                 }  
129.                 index++;  
130.             }  
131.         } catch (IOException e) {  
132.             System.out.println("发生内部异常错误，自动关闭[" + this.getId() + "]线程");  
133.             destroy();  
134.         } finally {  
135.             if (this.isAlive()) {  
136.                 destroy();  
137.             }  
138.         }  
139.     }  
140. }  

2.3、持久化服务
增加任务信息
删除任务信息
删除全部任务信息
查询任务信息
查询全部任务信息

        任务是否存在

[java] view plain copy

1. package cc.eguid.FFmpegCommandManager.dao;  
2.   
3. import java.util.Collection;  
4. import java.util.concurrent.ConcurrentHashMap;  
5. import java.util.concurrent.ConcurrentMap;  
6.   
7. import cc.eguid.FFmpegCommandManager.entity.TaskEntity;  
8.   
9. /** 
10.  * 任务信息持久层实现 
11.  *  
12.  * @author eguid 
13.  * @since jdk1.7 
14.  * @version 2016年10月29日 
15.  */  
16. public class TaskDaoImpl implements TaskDao {  
17.     // 存放任务信息  
18.     private ConcurrentMap<String, TaskEntity> map = null;  
19.   
20.     public TaskDaoImpl(int size) {  
21.         map = new ConcurrentHashMap<>(size);  
22.     }  
23.   
24.     @Override  
25.     public TaskEntity get(String id) {  
26.         return map.get(id);  
27.     }  
28.   
29.     @Override  
30.     public Collection<TaskEntity> getAll() {  
31.         return map.values();  
32.     }  
33.   
34.     @Override  
35.     public int add(TaskEntity taskEntity) {  
36.         String id = taskEntity.getId();  
37.         if (id != null && !map.containsKey(id)) {  
38.             if (map.put(taskEntity.getId(), taskEntity) != null) {  
39.                 return 1;  
40.             }  
41.         }  
42.         return 0;  
43.     }  
44.   
45.     @Override  
46.     public int remove(String id) {  
47.         if(map.remove(id) != null){  
48.             return 1;  
49.         };  
50.         return 0;  
51.     }  
52.   
53.     @Override  
54.     public int removeAll() {  
55.         int size = map.size();  
56.         try {  
57.             map.clear();  
58.         } catch (Exception e) {  
59.             return 0;  
60.         }  
61.         return size;  
62.     }  
63.   
64.     @Override  
65.     public boolean isHave(String id) {  
66.         return map.containsKey(id);  
67.     }  
68.   
69. }  

2.3命令组装器
用于将参数组装成对应的ffmpeg命令

[java] view plain copy

1. package cc.eguid.FFmpegCommandManager.util;  
2.   
3. import java.util.Map;  
4.   
5. public class CommandAssemblyUtil {  
6.     /** 
7.      *  
8.      * @param map 
9.      *            -要组装的map 
10.      * @param id 
11.      *            -返回参数：id 
12.      * @param id 
13.      *            -返回参数：组装好的命令 
14.      * @return 
15.      */  
16.     public static String assembly(Map<String, String> paramMap) {  
17.         try {  
18.             if (paramMap.containsKey("ffmpegPath")) {  
19.                 String ffmpegPath = (String) paramMap.get("ffmpegPath");  
20.                 // -i：输入流地址或者文件绝对地址  
21.                 StringBuilder comm = new StringBuilder(ffmpegPath + " -i ");  
22.                 // 是否有必输项：输入地址，输出地址，应用名，twoPart：0-推一个元码流；1-推一个自定义推流；2-推两个流（一个是自定义，一个是元码）  
23.                 if (paramMap.containsKey("input") && paramMap.containsKey("output") && paramMap.containsKey("appName")  
24.                         && paramMap.containsKey("twoPart")) {  
25.                     String input = (String) paramMap.get("input");  
26.                     String output = (String) paramMap.get("output");  
27.                     String appName = (String) paramMap.get("appName");  
28.                     String twoPart = (String) paramMap.get("twoPart");  
29.                     String codec = (String) paramMap.get("codec");  
30.                     // 默认h264解码  
31.                     codec = (codec == null ? "h264" : (String) paramMap.get("codec"));  
32.                     // 输入地址  
33.                     comm.append(input);  
34.                     // 当twoPart为0时，只推一个元码流  
35.                     if ("0".equals(twoPart)) {  
36.                         comm.append(" -vcodec " + codec + " -f flv -an " + output + appName);  
37.                     } else {  
38.                         // -f ：转换格式，默认flv  
39.                         if (paramMap.containsKey("fmt")) {  
40.                             String fmt = (String) paramMap.get("fmt");  
41.                             comm.append(" -f " + fmt);  
42.                         }  
43.                         // -r :帧率，默认25；-g :帧间隔  
44.                         if (paramMap.containsKey("fps")) {  
45.                             String fps = (String) paramMap.get("fps");  
46.                             comm.append(" -r " + fps);  
47.                             comm.append(" -g " + fps);  
48.                         }  
49.                         // -s 分辨率 默认是原分辨率  
50.                         if (paramMap.containsKey("rs")) {  
51.                             String rs = (String) paramMap.get("rs");  
52.                             comm.append(" -s " + rs);  
53.                         }  
54.                         // 输出地址+发布的应用名  
55.                         comm.append(" -an " + output + appName);  
56.                         // 当twoPart为2时推两个流，一个自定义流，一个元码流  
57.                         if ("2".equals(twoPart)) {  
58.                             // 一个视频源，可以有多个输出，第二个输出为拷贝源视频输出，不改变视频的各项参数并且命名为应用名+HD  
59.                             comm.append(" -vcodec copy  -f flv -an ").append(output + appName + "HD");  
60.                         }  
61.                     }  
62.                     return comm.toString();  
63.                 }  
64.             }  
65.         } catch (Exception e) {  
66.             return null;  
67.         }  
68.         return null;  
69.     }  
70. }  

2.4、配置文件读取器
读取配置文件中的ffmpeg路径配置
读取默认位置的ffmpeg执行文件

[java] view plain copy

1. package cc.eguid.FFmpegCommandManager.util;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.IOException;  
6. import java.util.Properties;  
7.   
8. /** 
9.  * 读取配置文件并加载FFmpeg 
10.  *  
11.  * @author eguid 
12.  * @since jdk1.7 
13.  * @version 2016年10月29日 
14.  */  
15. public class LoadConfig {  
16.     private volatile static boolean isHave = false;  
17.     private volatile static String ffmpegPath = null;  
18.   
19.     public LoadConfig() {  
20.         super();  
21.         if (readConfig()) {  
22.             System.out.println("读取FFmpeg执行路径成功！");  
23.             isHave = true;  
24.         } else if (initConfInfo()) {  
25.             // 配置文件读取失败，自动从项目路径加载ffmpeg  
26.             isHave = true;  
27.         } else {  
28.             isHave = false;  
29.         }  
30.   
31.     }  
32.   
33.     protected boolean readConfig() {  
34.         String path = null;  
35.         File confFile = new File(getClass().getResource("/").getPath() + "loadFFmpeg.properties");  
36.         System.out.println("读取FFMPEG配置文件:" + confFile.getPath());  
37.         if (confFile != null && confFile.exists() && confFile.isFile() && confFile.canRead()) {  
38.             Properties prop = new Properties();  
39.             try {  
40.                 prop.load(new FileInputStream(confFile));  
41.                 path = prop.getProperty("path");  
42.                 if (path != null) {  
43.                     System.out.println("读取配置文件中的ffmpeg路径：" + path);  
44.                     ffmpegPath = path;  
45.                     return true;  
46.                 }  
47.             } catch (IOException e) {  
48.                 System.err.println("读取配置文件失败!");  
49.                 return false;  
50.             }  
51.         }  
52.         System.err.println("读取配置文件失败!");  
53.         return false;  
54.     }  
55.   
56.     /** 
57.      * 从配置文件中初始化参数 
58.      */  
59.     protected boolean initConfInfo() {  
60.         String path = getClass().getResource("../").getPath() + "ffmpeg/ffmpeg.exe";  
61.         System.out.print("预加载默认项目路径FFMPEG配置:" + path);  
62.         File ffmpeg = new File(path);  
63.         ffmpegPath = ffmpeg.getPath();  
64.         if (isHave = ffmpeg.isFile()) {  
65.             return true;  
66.         }  
67.         System.out.println("加载ffmpeg失败！");  
68.         return false;  
69.     }  
70.   
71.     /** 
72.      * 判断ffmpeg环境配置 
73.      *  
74.      * @return true：配置成功；false：配置失败 
75.      */  
76.     public boolean isHave() {  
77.         return isHave;  
78.     }  
79.   
80.     /** 
81.      * 获取ffmpeg环境调用地址 添加方法功能描述 
82.      *  
83.      * @return 
84.      */  
85.     public String getPath() {  
86.         return ffmpegPath;  
87.     }  
88.   
89.     public static void main(String[] args) {  
90.         LoadConfig conf = new LoadConfig();  
91.     }  
92. }  

版权声明：做好自己！--eguid温馨提示：本博客所有原创文章均采用知识共享署名-相同方式共享 3.0 中国大陆许可协议进行许可。如有转载请注明出处和作者名！

• 本文已收录于以下专栏：
• 实时流媒体技术