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;  

    }  

      }

需要外部jar包