欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java实现切割wav音频文件的方法详解【附外部jar包下载】

程序员文章站 2024-02-24 13:11:47
本文实例讲述了java实现切割wav音频文件的方法。分享给大家供大家参考,具体如下: import it.sauronsoftware.jave.encoder;...

本文实例讲述了java实现切割wav音频文件的方法。分享给大家供大家参考,具体如下:

import it.sauronsoftware.jave.encoder;
import it.sauronsoftware.jave.multimediainfo;
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.nio.bytebuffer;
/**
 * wav音频文件截取工具
 * (适用于比特率为128kbps的wav音频文件,此类音频文件的头部信息占用长度44字节)
 * @author lwj
 *
 */
public class wavcut {
  /**
   * 截取wav音频文件
   * @param sourcepath 源文件地址
   * @param targetpath 目标文件地址
   * @param start 截取开始时间(秒)
   * @param end 截取结束时间(秒)
   *
   * return 截取成功返回true,否则返回false
   */
  public static boolean cut(string sourcefile, string targetfile, int start, int end) {
    try{
      if(!sourcefile.tolowercase().endswith(".wav") || !targetfile.tolowercase().endswith(".wav")){
        return false;
      }
      file wav = new file(sourcefile);
      if(!wav.exists()){
        return false;
      }
      long t1 = gettimelen(wav); //总时长(秒)
      if(start<0 || end<=0 || start>=t1 || end>t1 || start>=end){
        return false;
      }
      fileinputstream fis = new fileinputstream(wav);
      long wavsize = wav.length()-44; //音频数据大小(44为128kbps比特率wav文件头长度)
      long splitsize = (wavsize/t1)*(end-start); //截取的音频数据大小
      long skipsize = (wavsize/t1)*start; //截取时跳过的音频数据大小
      int splitsizeint = integer.parseint(string.valueof(splitsize));
      int skipsizeint = integer.parseint(string.valueof(skipsize));
      bytebuffer buf1 = bytebuffer.allocate(4); //存放文件大小,4代表一个int占用字节数
      buf1.putint(splitsizeint+36); //放入文件长度信息
      byte[] flen = buf1.array(); //代表文件长度
      bytebuffer buf2 = bytebuffer.allocate(4); //存放音频数据大小,4代表一个int占用字节数
      buf2.putint(splitsizeint); //放入数据长度信息
      byte[] dlen = buf2.array(); //代表数据长度
      flen = reverse(flen); //数组反转
      dlen = reverse(dlen);
      byte[] head = new byte[44]; //定义wav头部信息数组
      fis.read(head, 0, head.length); //读取源wav文件头部信息
      for(int i=0; i<4; i++){ //4代表一个int占用字节数
        head[i+4] = flen[i]; //替换原头部信息里的文件长度
        head[i+40] = dlen[i]; //替换原头部信息里的数据长度
      }
      byte[] fbyte = new byte[splitsizeint+head.length]; //存放截取的音频数据
      for(int i=0; i<head.length; i++){ //放入修改后的头部信息
        fbyte[i] = head[i];
      }
      byte[] skipbytes = new byte[skipsizeint]; //存放截取时跳过的音频数据
      fis.read(skipbytes, 0, skipbytes.length); //跳过不需要截取的数据
      fis.read(fbyte, head.length, fbyte.length-head.length); //读取要截取的数据到目标数组
      fis.close();
      file target = new file(targetfile);
      if(target.exists()){ //如果目标文件已存在,则删除目标文件
        target.delete();
      }
      fileoutputstream fos = new fileoutputstream(target);
      fos.write(fbyte);
      fos.flush();
      fos.close();
    }catch(ioexception e){
      e.printstacktrace();
      return false;
    }
    return true;
  }
  /**
   * 获取音频文件总时长
   * @param filepath 文件路径
   * @return
   */
  public static long gettimelen(file file){
    long tlen = 0;
    if(file!=null && file.exists()){
      encoder encoder = new encoder();
      try {
         multimediainfo m = encoder.getinfo(file);
         long ls = m.getduration();
         tlen = ls/1000;
      } catch (exception e) {
        e.printstacktrace();
      }
    }
    return tlen;
  }
  /**
  * 数组反转
  * @param array
  */
  public static byte[] reverse(byte[] array){
    byte temp;
    int len=array.length;
    for(int i=0;i<len/2;i++){
      temp=array[i];
      array[i]=array[len-1-i];
      array[len-1-i]=temp;
    }
    return array;
  }
  public static void main(string[] args){
    system.out.println(cut("f:\\111.wav","f:\\111-cut_0_10.wav",0,10));
    system.out.println(cut("f:\\111.wav","f:\\111-cut_10_20.wav",10,20));
    system.out.println(cut("f:\\111.wav","f:\\111-cut_20_28.wav",20,28));
  }
}

wave类型的音频文件切割时必须注意头信息,128kbps比特率的wave文件头信息占用44字节。

可以把头信息作为一个对象,用bytebuffer获取头信息。

注意:wave文件的头信息字节数组中每个属性都进行了数组反转

wave头信息对象模型如下:

/**
 * wave文件头信息
 * @author lwj
 *
 */
public class head {
  public int riff_id;      //4 byte , 'riff'
  public int file_size;     //4 byte , 文件长度(数据长度+36)
  public int riff_type;     //4 byte , 'wave'
  public int fmt_id;      //4 byte , 'fmt'
  public int fmt_size;     //4 byte , 数值为16或18,18则最后又附加信息
  public short fmt_tag;     //2 byte , 编码方式,一般为0x0001
  public short fmt_channel;   //2 byte , 声道数目,1--单声道;2--双声道
  public int fmt_samplespersec;//4 byte , 采样频率
  public int avgbytespersec;  //4 byte , 每秒所需字节数,记录每秒的数据量
  public short blockalign;   //2 byte , 数据块对齐单位(每个采样需要的字节数)
  public short bitspersample;  //2 byte , 每个采样需要的bit数
  public int data_id;      //4 byte , 字符data
  public int data_size;     //4 byte , 数据长度
  public int getriff_id() {
    return riff_id;
  }
  public void setriff_id(int riff_id) {
    this.riff_id = riff_id;
  }
  public int getfile_size() {
    return file_size;
  }
  public void setfile_size(int file_size) {
    this.file_size = file_size;
  }
  public int getriff_type() {
    return riff_type;
  }
  public void setriff_type(int riff_type) {
    this.riff_type = riff_type;
  }
  public int getfmt_id() {
    return fmt_id;
  }
  public void setfmt_id(int fmt_id) {
    this.fmt_id = fmt_id;
  }
  public int getfmt_size() {
    return fmt_size;
  }
  public void setfmt_size(int fmt_size) {
    this.fmt_size = fmt_size;
  }
  public short getfmt_tag() {
    return fmt_tag;
  }
  public void setfmt_tag(short fmt_tag) {
    this.fmt_tag = fmt_tag;
  }
  public short getfmt_channel() {
    return fmt_channel;
  }
  public void setfmt_channel(short fmt_channel) {
    this.fmt_channel = fmt_channel;
  }
  public int getfmt_samplespersec() {
    return fmt_samplespersec;
  }
  public void setfmt_samplespersec(int fmt_samplespersec) {
    this.fmt_samplespersec = fmt_samplespersec;
  }
  public int getavgbytespersec() {
    return avgbytespersec;
  }
  public void setavgbytespersec(int avgbytespersec) {
    this.avgbytespersec = avgbytespersec;
  }
  public short getblockalign() {
    return blockalign;
  }
  public void setblockalign(short blockalign) {
    this.blockalign = blockalign;
  }
  public short getbitspersample() {
    return bitspersample;
  }
  public void setbitspersample(short bitspersample) {
    this.bitspersample = bitspersample;
  }
  public int getdata_id() {
    return data_id;
  }
  public void setdata_id(int data_id) {
    this.data_id = data_id;
  }
  public int getdata_size() {
    return data_size;
  }
  public void setdata_size(int data_size) {
    this.data_size = data_size;
  }
}

附件为wave切割程序所依赖的外部jar包:

更多关于java算法相关内容感兴趣的读者可查看本站专题:《java文件与目录操作技巧汇总》、《java数据结构与算法教程》、《java操作dom节点技巧总结》和《java缓存操作技巧汇总

希望本文所述对大家java程序设计有所帮助。