java 实现视频转换通用工具类：获取视频元数据信息（一）

java 做视频转换主要用到开源的ffmpeg或者mencoder，还要有MP4Box。

注：由于平时都没有时间写博客，所以思路我就不写了，有问题问我，不一定马上回复。

详细介绍：

ffmpeg：http://www.ffmpeg.org/

mencoder：http://en.wikipedia.org/wiki/MEncoder

MP4Box：http://gpac.wp.mines-telecom.fr/mp4box/mp4box-documentation/

主要实现：

1.获取视频元数据信息
2.视频相互转换
3.视频加文字及图片水印
4.视频截图

思路：

配置文件中定义各转换工具的路径：（相关工具去官网下载）

1. <!-- ################配置系统用到的转换工具相关参数   开始....-->
2. <!-- ##ffmpeg.so文件路径 -->
3. <param name="ffmpegPath" value="D:\conver\ffmpeg-win.exe" />
4. <!-- ##memcoder.so文件路径 -->
5. <param name="mencoderPath" value="D:\conver\mencoder.exe" />
6. <!-- ##给视频加水印的shell脚本路径 -->
7. <param name="shellPath" value="D:\conver\coverVideo.bat" />
8. <!-- ##定义MP4Box工具路径 -->
9. <param name="mp4BoxPath" value="D:\conver\MP4Box" />
10. <!-- ##定义图片转换工具路径 -->
11. <param name="imgConverPath" value="C:/Program Files/ImageMagick-6.3.9-Q16/convert.exe" />
12. <!-- ################配置系统用到的转换工具相关参数   结束-->

2.获取视频音频的各项属性帮助类

1. import java.io.BufferedReader;
2. import java.io.InputStreamReader;
3. import java.util.List;
4. import org.apache.commons.lang.StringUtils;
5. import org.apache.log4j.Logger;
6. import org.apache.oro.text.regex.MalformedPatternException;
7. import org.apache.oro.text.regex.MatchResult;
8. import org.apache.oro.text.regex.Pattern;
9. import org.apache.oro.text.regex.PatternCompiler;
10. import org.apache.oro.text.regex.PatternMatcher;
11. import org.apache.oro.text.regex.Perl5Compiler;
12. import org.apache.oro.text.regex.Perl5Matcher;
13. import com.brainsoon.bsrcm.common.utils.BaseCommonUtil;
14. import com.brainsoon.bsrcm.system.support.CacConver;
15. /**
16. * 获取视频音频的各项属性帮助类
17. * 如果需要修改或者添加属性，只要扩展下面的二维数组和修改下面getVideoInfo()方法
18. * @author tanghui
19. *
20. */
21. public class VideoInfoHelps {
22. protected static final Logger logger = Logger.getLogger(VideoInfoHelps.class);
23. public static final String ffmpegPath; // ffmpeg.exe的目录
24. static{
25. ffmpegPath = BaseCommonUtil.getProRealPath("ffmpegPath");
26. }
27. /**
28. * 根据属性获取视频信息
29. * @param videoPath
30. * @return
31. */
32. public static VideoInfo getVideoInfo(String videoPath) {
33. VideoInfo videoInfo  = new VideoInfo();
34. if(CacConver.exitFile(videoPath)){
35. String videoType = videoPath.substring(videoPath.lastIndexOf(".")+1, videoPath.length());
36. if(CacConver.isNeedVideoFormat(videoType)){
37. String result =   processVideo(videoPath);
38. if(StringUtils.isNotEmpty(result)){
39. PatternCompiler compiler =new Perl5Compiler();
40. try {
41. String regexDuration ="Duration: (.*?), start: (.*?), bitrate: (\\d*) kb\\/s";
42. String regexVideo ="Video: (.*?), (.*?), (.*?)[,\\s]";
43. String regexAudio ="Audio: (\\w*), (\\d*) Hz";
44. Pattern patternDuration = compiler.compile(regexDuration,Perl5Compiler.CASE_INSENSITIVE_MASK);
45. PatternMatcher matcherDuration = new Perl5Matcher();
46. if(matcherDuration.contains(result, patternDuration)){
47. MatchResult re = matcherDuration.getMatch();
48. videoInfo.setPlayingAllTime( re.group(1));
49. videoInfo.setPlayingStartTime( re.group(2));
50. videoInfo.setBitrateSize( re.group(3));
51. }
52. Pattern patternVideo = compiler.compile(regexVideo,Perl5Compiler.CASE_INSENSITIVE_MASK);
53. PatternMatcher matcherVideo = new Perl5Matcher();
54. if(matcherVideo.contains(result, patternVideo)){
55. MatchResult re = matcherVideo.getMatch();
56. videoInfo.setCodeFormat( re.group(1));
57. videoInfo.setVideoFormat( re.group(2));
58. videoInfo.setResolution( re.group(3));
59. }
60. Pattern patternAudio = compiler.compile(regexAudio,Perl5Compiler.CASE_INSENSITIVE_MASK);
61. PatternMatcher matcherAudio = new Perl5Matcher();
62. if(matcherAudio.contains(result, patternAudio)){
63. MatchResult re = matcherAudio.getMatch();
64. videoInfo.setAudioCoding(re.group(1));
65. videoInfo.setAudioFrequency( re.group(2));
66. }
67. } catch (MalformedPatternException e) {
68. logger.error("获取【" + videoPath +"】视频信息失败!");
69. }
70. logger.info("获取【" + videoPath +"】视频信息成功!");
71. }else{
72. logger.info("执行成功！但未获取到【" + videoPath +"】视频信息!");
73. }
74. }else{
75. logger.debug("【" + videoPath + "】文件格式不支持！");
76. }
77. }
78. return videoInfo ;
79. }
80. /**
81. *  ffmpeg能解析的格式：（asx，asf，mpg，wmv，3gp，mp4，mov，avi，flv等）
82. * @param inputPath
83. * @return
84. */
85. private static String processVideo(String filePath) {
86. List<String> commend=new java.util.ArrayList<String>();
87. commend.add(ffmpegPath);//可以设置环境变量从而省去这行
88. commend.add("-i");
89. commend.add(filePath);
90. try {
91. ProcessBuilder builder = new ProcessBuilder();
92. builder.command(commend);
93. builder.redirectErrorStream(true);
94. Process p= builder.start();
95. BufferedReader buf = null; // 保存ffmpeg的输出结果流
96. String line = null;
97. buf = new BufferedReader(new InputStreamReader(p.getInputStream()));
98. StringBuffer sb= new StringBuffer();
99. while ((line = buf.readLine()) != null) {
100. sb.append(line);
101. continue;
102. }
103. p.waitFor();//这里线程阻塞，将等待外部转换进程运行成功运行结束后，才往下执行
104. return sb.toString();
105. } catch (Exception e) {
106. logger.error("ffmpeg解析视频文件【" + filePath +"】失败!");
107. return null;
108. }
109. }
110. }

3.其他的工具类

1. /**
2. * 等待进程处理
3. * @param p
4. * @return
5. */
6. @SuppressWarnings("unused")
7. public static int doWaitFor(Process p) {
8. InputStream in = null;
9. InputStream err = null;
10. int exitValue = -1; // returned to caller when p is finished
11. try {
12. in = p.getInputStream();
13. err = p.getErrorStream();
14. boolean finished = false; // Set to true when p is finished
15. while (!finished) {
16. try {
17. while (in.available() > 0) {
18. Character c = new Character((char) in.read());
19. }
20. while (err.available() > 0) {
21. Character c = new Character((char) err.read());
22. }
23. exitValue = p.exitValue();
24. finished = true;
25. } catch (IllegalThreadStateException e) {
26. Thread.currentThread();
27. Thread.sleep(500);
28. }
29. }
30. } catch (Exception e) {
31. logger.error("doWaitFor();: unexpected exception - "
32. + e.getMessage());
33. } finally {
34. try {
35. if (in != null) {
36. in.close();
37. }
38. } catch (IOException e) {
39. logger.error("等待进程处理错误");
40. }
41. if (err != null) {
42. try {
43. err.close();
44. } catch (IOException e) {
45. logger.error("等待进程处理错误");
46. }
47. }
48. }
49. return exitValue;
50. }
51. /**
52. * 删除文件
53. * @param filepath
54. */
55. public static void deleteFile(String filepath) {
56. File file = new File(filepath);
57. if (file.exists()) {
58. if (file.delete()) {
59. logger.info("文件【" + filepath + "】已删除");
60. }
61. }
62. }
63. /**
64. * 根据时间返回总秒数 形如：（00:12:12）
65. * @param timeStr
66. * @return
67. */
68. public static String getSplitStr(String timeStr){
69. String secStr="0";//返回秒
70. if(timeStr != null && !timeStr.equals("") ){
71. String[] str = timeStr.split(":");
72. int subInt0 = Integer.parseInt(str[0]);
73. int subInt1 = Integer.parseInt(str[1]);
74. String str2s = "";
75. if(str[2].length() >2&&str[2].indexOf(".")>0){
76. str2s = str[2].substring(0,str[2].indexOf("."));
77. }else{
78. str2s =  str[2];
79. }
80. int subInt2 = Integer.parseInt(str2s);
81. Long countNum = subInt0 * 3600L + subInt1 * 60 + subInt2;
82. secStr = countNum + "";
83. }
84. return secStr;
85. }
86. /**
87. * 计算两个字符串时间相减 如：("00:22:22")
88. *
89. * @param time1
90. * @param time2
91. * @return
92. */
93. public static String calTime(String time1, String time2){
94. Long time1Long = Long.parseLong(time1);
95. Long time2Long = Long.parseLong(time2);
96. Long timeLong = time2Long-time1Long;
97. StringBuffer sbuffer = null;
98. if(timeLong > 0){
99. int hour = (int) (timeLong/3600);
100. int minute = (int) ((timeLong-hour*3600)/60);
101. int second =(int) ((timeLong-hour*3600-minute*60)%60);
102. sbuffer = new StringBuffer();
103. if(hour<10){
104. sbuffer.append("0");
105. }
106. sbuffer.append(Integer.toString(hour));
107. sbuffer.append(":");
108. if(minute<10){
109. sbuffer.append("0");
110. }
111. sbuffer.append(Integer.toString(minute));
112. sbuffer.append(":");
113. if(second<10){
114. sbuffer.append("0");
115. }
116. sbuffer.append(Integer.toString(second));
117. return sbuffer.toString();
118. }else{
119. logger.error("时间不能为负数！可能原因是传入的时间位置不对!");
120. return "";
121. }
122. }