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包