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

时间：2020-11-28 17:31:24

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

相关文章