Spaces:
Sleeping
Sleeping
| package audio | |
| import ( | |
| "bytes" | |
| "encoding/binary" | |
| "errors" | |
| "fmt" | |
| "io" | |
| "math" | |
| "os" | |
| "path/filepath" | |
| ) | |
| /* | |
| -----RIFF----- | |
| RIFF 4 标头字母 | |
| CHUNK_SIZE 4 整个RIFF文件的长度(不包含RIFF和CHUNK_SIZE这两个字段的长度) | |
| FORMAT 4 格式,WAVE代表是wav文件,WAVE格式要求带有标头为fmt和data的子chunk | |
| -----FMT ----- | |
| SUB_CHUNK_ID 4 子chunk的标头字母,此处为"fmt "(注意,fmt后面是带一个空格的),其相当于wav的属性字段 | |
| SUB_CHUNK_SIZE 4 此subchunk的长度(不包含SUB_CHUNK_ID和SUB_CHUNK_SIZE两个字段的长度) | |
| AUDIO_FORMAT 2 音频格式,pcm为1 | |
| NUM_CHANNELS 2 声道数量,理论上可以n声道,一般我们用单声道mono,或者双声道stereo(双声道也叫立体声) | |
| SAMPLE_RATE 4 采样率,每秒采样多少次,通常都有固定的采样选择(8000, 11025,12000,16000,22050,24000,32000,44100,48000) | |
| BYTE_RATE 4 码率,即每秒播放多少byte数据,计算公式=SAMPLE_RATE*NUM_CHANNELS*BITS_PER_SAMPLE/8(不明白为何需要这个字段) | |
| BLOCK_ALIGN 2 块对其,其值=BITS_PER_SAMPLE*NUM_CHANNELS/8 | |
| BITS_PER_SAMPLE 2 每个采样多少bit,通常为8,16,32(为8时候代表的是uint8,16代表的是int16,32代表float32) | |
| -----DATA----- | |
| SUB_CHUNK_ID 4 子chunk的标头字母,此处为"data" | |
| SUB_CHUNK_SIZE 4 此subchunk的长度(不包含SUB_CHUNK_ID和SUB_CHUNK_SIZE两个字段的长度) | |
| DATA pcm的数据 | |
| ------------- | |
| */ | |
| //MaxChannelNum 最大声道数量(此处只允许2） | |
| const MaxChannelNum = 2 | |
| const ( | |
| LeftChannel = 0 | |
| RightChannel =1 | |
| ) | |
| //tag tag定义 | |
| type tag [4]byte | |
| //一些变量 | |
| var ( | |
| tagRIFF = tag{'R', 'I', 'F', 'F'} // "RIFF" | |
| tagWAVE = tag{'W', 'A', 'V', 'E'} // "WAVE" | |
| tagFmt = tag{'f', 'm', 't', ' '} // "fmt " | |
| tagData = tag{'d', 'a', 't', 'a'} // "data" | |
| ) | |
| //WavHeaderType wav子部头结构 | |
| type WavHeaderType struct { | |
| ID tag | |
| Size uint32 | |
| } | |
| //String 打印 | |
| func (wavHeader *WavHeaderType) String() string { | |
| return fmt.Sprintf("ID=%s,Size=%d", string(wavHeader.ID[:]), wavHeader.Size) | |
| } | |
| //头部size | |
| var ( | |
| sizeHeader = binary.Size(WavHeaderType{}) | |
| ) | |
| //chunkLoc ... | |
| type chunkLoc struct { | |
| pos int64 | |
| size int64 | |
| } | |
| //RiffType ... | |
| type RiffType struct { | |
| WavHeaderType | |
| Fmt tag | |
| } | |
| //String ... | |
| func (riff *RiffType) String() string { | |
| return fmt.Sprintf("ID=%s,Size=%d,Fmt=%s", string(riff.ID[:]), riff.Size, string(riff.Fmt[:])) | |
| } | |
| //WavFmtType wav格式结构（头部） | |
| type WavFmtType struct { | |
| WavHeaderType | |
| AudioFormat uint16 | |
| Channels uint16 | |
| SampleRate uint32 | |
| BytesPerSec uint32 | |
| BytesPerBlock uint16 | |
| BitsPerSample uint16 | |
| } | |
| //String ... | |
| func (wavFmt *WavFmtType) String() string { | |
| return fmt.Sprintf( | |
| "ID=%s,Size=%d,AudioFormat=%d,Channels=%d,SampleRate=%d,BytesPerSec=%d,BytesPerBlock=%d,BitsPerSample=%d", | |
| string(wavFmt.ID[:]), wavFmt.Size, wavFmt.AudioFormat, wavFmt.Channels, wavFmt.SampleRate, | |
| wavFmt.BytesPerSec, wavFmt.BytesPerBlock, wavFmt.BitsPerSample) | |
| } | |
| //SampleType 采样结构 | |
| type SampleType struct { | |
| val8s [MaxChannelNum]uint8 | |
| val16s [MaxChannelNum]int16 | |
| val32s [MaxChannelNum]float32 | |
| } | |
| //WavDataType wav整体结构（头部+采样数据结构） | |
| type WavDataType struct { | |
| WavHeaderType | |
| Sample []SampleType | |
| } | |
| //String ... | |
| func (wavData *WavDataType) String() string { | |
| blockNum := len(wavData.Sample) | |
| return fmt.Sprintf("ID=%s,Size=%d,BlockNum=%d", string(wavData.ID[:]), wavData.Size, blockNum) | |
| } | |
| //WavInfoType wav操作实例 | |
| type WavInfoType struct { | |
| Riff RiffType | |
| Fmt WavFmtType | |
| Data WavDataType | |
| //create info | |
| createMs int64 | |
| } | |
| //String ... | |
| func (wavInfo *WavInfoType) String() string { | |
| f := &wavInfo.Fmt | |
| blockNum := len(wavInfo.Data.Sample) | |
| return fmt.Sprintf("SampleRate=%d,BitsPerSample=%d,Channels=%d,BlockNum=%d", | |
| f.SampleRate, f.BitsPerSample, f.Channels, blockNum) | |
| } | |
| //SetCreateTs ... | |
| func (wavInfo *WavInfoType) SetCreateTs(timestampMs int64) { | |
| wavInfo.createMs = timestampMs | |
| } | |
| //CopyFormat 复制头部结构 | |
| func (wavInfo *WavInfoType) CopyFormat(w *WavInfoType) (err error) { | |
| wavInfo.Riff.ID = w.Riff.ID | |
| wavInfo.Riff.Size = w.Riff.Size | |
| wavInfo.Riff.Fmt = w.Riff.Fmt | |
| wavInfo.Fmt.ID = w.Fmt.ID | |
| wavInfo.Fmt.Size = w.Fmt.Size | |
| wavInfo.Fmt.AudioFormat = w.Fmt.AudioFormat | |
| wavInfo.Fmt.Channels = w.Fmt.Channels | |
| wavInfo.Fmt.SampleRate = w.Fmt.SampleRate | |
| wavInfo.Fmt.BytesPerSec = w.Fmt.BytesPerSec | |
| wavInfo.Fmt.BytesPerBlock = w.Fmt.BytesPerBlock | |
| wavInfo.Fmt.BitsPerSample = w.Fmt.BitsPerSample | |
| wavInfo.Data.ID = w.Data.ID | |
| wavInfo.Data.Size = w.Data.Size | |
| return | |
| } | |
| //ParseFromFile 从文件中导入 | |
| func (wavInfo *WavInfoType) ParseFromFile(absFile string) (err error) { | |
| absFile, err = filepath.Abs(absFile) //#nosec | |
| if err != nil { | |
| return err | |
| } | |
| fileHandler, err := os.Open(absFile) //#nosec | |
| if err != nil { | |
| return err | |
| } | |
| defer fileHandler.Close() | |
| _, err = fileHandler.Seek(0, os.SEEK_SET) | |
| if err != nil { | |
| return err | |
| } | |
| var pos int64 | |
| var ch WavHeaderType | |
| //----------------------------------------------------- | |
| // RIFF header | |
| err = binary.Read(fileHandler, binary.LittleEndian, &wavInfo.Riff) | |
| if err != nil { | |
| return err | |
| } | |
| pos += int64(sizeHeader) + int64(len(tagWAVE)) | |
| if wavInfo.Riff.ID != tagRIFF { | |
| return errors.New("File Format Not Riff") | |
| } | |
| if wavInfo.Riff.Fmt != tagWAVE { | |
| return errors.New("File Format Not Wave") | |
| } | |
| fileSize := int64(sizeHeader) + int64(wavInfo.Riff.Size) | |
| _ = fileSize | |
| //r := &wavInfo.Riff | |
| //----------------------------------------------------- | |
| // read all chunks | |
| var chunks = make(map[tag]*chunkLoc) | |
| for { | |
| err = binary.Read(fileHandler, binary.LittleEndian, &ch) | |
| if err != nil { | |
| if err == io.EOF { | |
| break | |
| } | |
| return err | |
| } | |
| pos += int64(sizeHeader) | |
| loc := chunkLoc{ | |
| pos: pos, | |
| size: int64(ch.Size), | |
| } | |
| _, err = fileHandler.Seek(loc.size, os.SEEK_CUR) | |
| if err != nil { | |
| return err | |
| } | |
| pos += loc.size // chunk data | |
| chunks[ch.ID] = &loc | |
| } | |
| // check fileHandler size | |
| if pos != fileSize { | |
| return errors.New("pos != fileSize") | |
| } | |
| //----------------------------------------------------- | |
| // chunk fmt_ | |
| loc, ok := chunks[tagFmt] | |
| if !ok { | |
| return errors.New("wav: has not chunk \"fmt \"") | |
| } | |
| _, err = fileHandler.Seek(loc.pos-int64(sizeHeader), os.SEEK_SET) | |
| if err != nil { | |
| return err | |
| } | |
| err = binary.Read(fileHandler, binary.LittleEndian, &wavInfo.Fmt) | |
| if err != nil { | |
| return err | |
| } | |
| //----------------------------------------------------- | |
| // chunk data | |
| loc, ok = chunks[tagData] | |
| if !ok { | |
| return errors.New("wav: has not chunk \"data\"") | |
| } | |
| _, err = fileHandler.Seek(loc.pos, os.SEEK_SET) | |
| if err != nil { | |
| return err | |
| } | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| blockSize := channel * bytePerSample | |
| wavInfo.Data.ID = tagData | |
| wavInfo.Data.Size = uint32(loc.size) | |
| blockNum := wavInfo.Data.Size / uint32(blockSize) | |
| wavInfo.Data.Sample = make([]SampleType, blockNum) | |
| _, err = fileHandler.Seek(loc.pos, os.SEEK_SET) | |
| if err != nil { | |
| return err | |
| } | |
| blockIdx := 0 | |
| for i := 0; i < int(wavInfo.Data.Size); i += int(blockSize) { | |
| sample := &wavInfo.Data.Sample[blockIdx] | |
| blockIdx++ | |
| for c := 0; c < int(channel); c++ { | |
| switch bytePerSample { | |
| case 1: | |
| var val uint8 | |
| err = binary.Read(fileHandler, binary.LittleEndian, &val) | |
| //sample.val8s = append(sample.val8s,val) | |
| sample.val8s[c] = val | |
| case 2: | |
| var val int16 | |
| err = binary.Read(fileHandler, binary.LittleEndian, &val) | |
| //sample.val16s = append(sample.val16s,val) | |
| sample.val16s[c] = val | |
| //fmt.Printf("pos=%d,val=%d\n",i,sample.val16s) | |
| case 4: | |
| var val float32 | |
| err = binary.Read(fileHandler, binary.LittleEndian, &val) | |
| //sample.val32s = append(sample.val32s,val) | |
| sample.val32s[c] = val | |
| } | |
| if err != nil { | |
| return err | |
| } | |
| } | |
| //wavInfo.Data.Sample = append(wavInfo.Data.Sample,sample) | |
| } | |
| //for i:=0;i<len(wavInfo.Data.Sample);i++{ | |
| // sample := &wavInfo.Data.Sample[i] | |
| // fmt.Printf("idx=%d,left=%d,right=%d\n",i,sample.val16s[0],sample.val16s[1]) | |
| //} | |
| for id, chunk := range chunks { | |
| if id != tagData && id != tagFmt { | |
| //util.MainLogger.Error(fmt.Sprintf("unkonw chunk=%s,size=%d\n", string(id[:]), chunk.size)) | |
| fmt.Printf("unkonw chunk=%s,size=%d\n", string(id[:]), chunk.size) | |
| } | |
| } | |
| return | |
| } | |
| //ParseFromBuffer 从buffer中导入 | |
| func (wavInfo *WavInfoType) ParseFromBuffer(buffer []byte) (err error) { | |
| var ch WavHeaderType | |
| bufferReader := bytes.NewBuffer(buffer) | |
| //----------------------------------------------------- | |
| // RIFF header | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Riff) | |
| if err != nil { | |
| return err | |
| } | |
| //pos := int64(sizeHeader) + int64(len(tagWAVE)) | |
| if wavInfo.Riff.ID != tagRIFF { | |
| return errors.New("File Format Not Riff") | |
| } | |
| if wavInfo.Riff.Fmt != tagWAVE { | |
| return errors.New("File Format Not Wave") | |
| } | |
| fileSize := int64(sizeHeader) + int64(wavInfo.Riff.Size) | |
| _ = fileSize | |
| //r := &wavInfo.Riff | |
| //----------------------------------------------------- | |
| // read all chunks | |
| for { | |
| err = binary.Read(bufferReader, binary.LittleEndian, &ch) | |
| if err != nil { | |
| if err == io.EOF { | |
| //文件读取结束 | |
| err = nil | |
| return | |
| } | |
| return err | |
| } | |
| //fmt格式的chunk | |
| if ch.ID == tagFmt { | |
| wavInfo.Fmt.WavHeaderType = ch | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.AudioFormat) | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.Channels) | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.SampleRate) | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.BytesPerSec) | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.BytesPerBlock) | |
| err = binary.Read(bufferReader, binary.LittleEndian, &wavInfo.Fmt.BitsPerSample) | |
| if err != nil { | |
| return err | |
| } | |
| continue | |
| } | |
| //data格式的chunk | |
| if ch.ID == tagData { | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| blockSize := channel * bytePerSample | |
| wavInfo.Data.ID = tagData | |
| wavInfo.Data.Size = ch.Size | |
| blockNum := wavInfo.Data.Size / uint32(blockSize) | |
| wavInfo.Data.Sample = make([]SampleType, blockNum) | |
| blockIdx := 0 | |
| for i := 0; i < int(wavInfo.Data.Size); i += int(blockSize) { | |
| sample := &wavInfo.Data.Sample[blockIdx] | |
| blockIdx++ | |
| for c := 0; c < int(channel); c++ { | |
| switch bytePerSample { | |
| case 1: | |
| var val uint8 | |
| err = binary.Read(bufferReader, binary.LittleEndian, &val) | |
| //sample.val8s = append(sample.val8s,val) | |
| sample.val8s[c] = val | |
| case 2: | |
| var val int16 | |
| err = binary.Read(bufferReader, binary.LittleEndian, &val) | |
| //sample.val16s = append(sample.val16s,val) | |
| sample.val16s[c] = val | |
| //fmt.Printf("pos=%d,val=%d\n",i,sample.val16s) | |
| case 4: | |
| var val float32 | |
| err = binary.Read(bufferReader, binary.LittleEndian, &val) | |
| //sample.val32s = append(sample.val32s,val) | |
| sample.val32s[c] = val | |
| } | |
| if err != nil { | |
| return err | |
| } | |
| } | |
| //wavInfo.Data.Sample = append(wavInfo.Data.Sample,sample) | |
| } | |
| continue | |
| } | |
| //其他格式的chunk | |
| byteData := make([]byte, ch.Size) | |
| err = binary.Read(bufferReader, binary.LittleEndian, byteData) | |
| } | |
| return | |
| } | |
| //SaveToFile 保存到文件中 | |
| func (wavInfo *WavInfoType) SaveToFile(absFile string) (err error) { | |
| file, err := os.Create(absFile) | |
| if err != nil { | |
| return | |
| } | |
| defer file.Close() | |
| _, err = file.Seek(0, os.SEEK_SET) | |
| if err != nil { | |
| return | |
| } | |
| //calc size | |
| wavInfo.Data.Size = (uint32(wavInfo.Fmt.Channels) * uint32(wavInfo.Fmt.BitsPerSample) / 8) * | |
| uint32(len(wavInfo.Data.Sample)) | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| wavInfo.Riff.Size = uint32(len(wavInfo.Riff.Fmt)) + | |
| uint32(sizeHeader) + | |
| wavInfo.Fmt.Size + | |
| uint32(sizeHeader) + | |
| wavInfo.Data.Size | |
| //---------------------------------------- | |
| // RIFF header | |
| err = binary.Write(file, binary.LittleEndian, wavInfo.Riff) | |
| if err != nil { | |
| return err | |
| } | |
| //---------------------------------------- | |
| // chunk fmt_ | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| err = binary.Write(file, binary.LittleEndian, wavInfo.Fmt) | |
| if err != nil { | |
| return err | |
| } | |
| //---------------------------------------- | |
| // chunk data | |
| ch := WavHeaderType{ | |
| ID: tagData, | |
| Size: wavInfo.Data.Size, | |
| } | |
| err = binary.Write(file, binary.LittleEndian, ch) | |
| if err != nil { | |
| return err | |
| } | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| sample := &wavInfo.Data.Sample[i] | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(file, binary.LittleEndian, sample.val8s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(file, binary.LittleEndian, sample.val16s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(file, binary.LittleEndian, sample.val32s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| } | |
| return | |
| } | |
| //SaveToBuffer 保存到buffer中 | |
| func (wavInfo *WavInfoType) SaveToBuffer() (buffer []byte, err error) { | |
| //var bufferWriter bytes.Buffer | |
| buffer = make([]byte, 0) | |
| bufferWriter := bytes.NewBuffer(buffer) | |
| //calc size | |
| wavInfo.Data.Size = (uint32(wavInfo.Fmt.Channels) * uint32(wavInfo.Fmt.BitsPerSample) / 8) * | |
| uint32(len(wavInfo.Data.Sample)) | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| wavInfo.Riff.Size = uint32(len(wavInfo.Riff.Fmt)) + | |
| uint32(sizeHeader) + | |
| wavInfo.Fmt.Size + | |
| uint32(sizeHeader) + | |
| wavInfo.Data.Size | |
| //---------------------------------------- | |
| // RIFF header | |
| err = binary.Write(bufferWriter, binary.LittleEndian, wavInfo.Riff) | |
| if err != nil { | |
| return | |
| } | |
| //---------------------------------------- | |
| // chunk fmt_ | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| err = binary.Write(bufferWriter, binary.LittleEndian, wavInfo.Fmt) | |
| if err != nil { | |
| return | |
| } | |
| //---------------------------------------- | |
| // chunk data | |
| ch := WavHeaderType{ | |
| ID: tagData, | |
| Size: wavInfo.Data.Size, | |
| } | |
| err = binary.Write(bufferWriter, binary.LittleEndian, ch) | |
| if err != nil { | |
| return | |
| } | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| sample := &wavInfo.Data.Sample[i] | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val8s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val16s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val32s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| } | |
| buffer = bufferWriter.Bytes() | |
| return | |
| } | |
| //SaveToBuffer 保存到buffer中 | |
| func (wavInfo *WavInfoType) SaveToBufferWithChannel(voiceChannel int) (buffer []byte, err error) { | |
| //var bufferWriter bytes.Buffer | |
| buffer = make([]byte, 0) | |
| bufferWriter := bytes.NewBuffer(buffer) | |
| //calc size | |
| channel := wavInfo.Fmt.Channels | |
| wavInfo.Fmt.Channels = 1 | |
| wavInfo.Data.Size = (uint32(wavInfo.Fmt.Channels) * uint32(wavInfo.Fmt.BitsPerSample) / 8) * | |
| uint32(len(wavInfo.Data.Sample)) | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| wavInfo.Riff.Size = uint32(len(wavInfo.Riff.Fmt)) + | |
| uint32(sizeHeader) + | |
| wavInfo.Fmt.Size + | |
| uint32(sizeHeader) + | |
| wavInfo.Data.Size | |
| //---------------------------------------- | |
| // RIFF header | |
| err = binary.Write(bufferWriter, binary.LittleEndian, wavInfo.Riff) | |
| if err != nil { | |
| return | |
| } | |
| //---------------------------------------- | |
| // chunk fmt_ | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| err = binary.Write(bufferWriter, binary.LittleEndian, wavInfo.Fmt) | |
| if err != nil { | |
| return | |
| } | |
| //---------------------------------------- | |
| // chunk data | |
| ch := WavHeaderType{ | |
| ID: tagData, | |
| Size: wavInfo.Data.Size, | |
| } | |
| err = binary.Write(bufferWriter, binary.LittleEndian, ch) | |
| if err != nil { | |
| return | |
| } | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| sample := &wavInfo.Data.Sample[i] | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val8s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val16s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(bufferWriter, binary.LittleEndian, sample.val32s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| } | |
| } | |
| buffer = bufferWriter.Bytes() | |
| wavInfo.Fmt.Channels = 2 | |
| return | |
| } | |
| //SaveToFile 保存到文件中 | |
| func (wavInfo *WavInfoType) SaveToFileWithChannel(absFile string, voiceChannel int) (err error) { | |
| file, err := os.Create(absFile) | |
| if err != nil { | |
| return | |
| } | |
| defer file.Close() | |
| _, err = file.Seek(0, io.SeekStart) | |
| if err != nil { | |
| return | |
| } | |
| //calc size | |
| channel := wavInfo.Fmt.Channels | |
| wavInfo.Fmt.Channels = 1 | |
| wavInfo.Data.Size = (uint32(wavInfo.Fmt.Channels) * uint32(wavInfo.Fmt.BitsPerSample) / 8) * | |
| uint32(len(wavInfo.Data.Sample)) | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| wavInfo.Riff.Size = uint32(len(wavInfo.Riff.Fmt)) + | |
| uint32(sizeHeader) + | |
| wavInfo.Fmt.Size + | |
| uint32(sizeHeader) + | |
| wavInfo.Data.Size | |
| //---------------------------------------- | |
| // RIFF header | |
| err = binary.Write(file, binary.LittleEndian, wavInfo.Riff) | |
| if err != nil { | |
| return err | |
| } | |
| //---------------------------------------- | |
| // chunk fmt_ | |
| wavInfo.Fmt.Size = uint32(binary.Size(wavInfo.Fmt)) - uint32(sizeHeader) | |
| err = binary.Write(file, binary.LittleEndian, wavInfo.Fmt) | |
| if err != nil { | |
| return err | |
| } | |
| //---------------------------------------- | |
| // chunk data | |
| ch := WavHeaderType{ | |
| ID: tagData, | |
| Size: wavInfo.Data.Size, | |
| } | |
| err = binary.Write(file, binary.LittleEndian, ch) | |
| if err != nil { | |
| return err | |
| } | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| sample := &wavInfo.Data.Sample[i] | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(file, binary.LittleEndian, sample.val8s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(file, binary.LittleEndian, sample.val16s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| if voiceChannel == c { | |
| err = binary.Write(file, binary.LittleEndian, sample.val32s[c]) | |
| if err != nil { | |
| return | |
| } | |
| } | |
| } | |
| } | |
| } | |
| wavInfo.Fmt.Channels = 2 | |
| return | |
| } | |
| //AdjusterVolume 调整音量 | |
| func (wavInfo *WavInfoType) AdjusterVolume(rateAsRaw float32) { | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| const MaxUint8 = math.MaxUint8 | |
| const MinUint8 = 0 | |
| const MaxInt16 = math.MaxInt16 | |
| const MinInt16 = math.MinInt16 | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val8s[c] | |
| clip := float64(val) * float64(rateAsRaw) | |
| if clip < MinUint8 { | |
| clip = MinUint8 | |
| } | |
| if clip > MaxUint8 { | |
| clip = MaxUint8 | |
| } | |
| //wavInfo.Data.Sample[i].val8s[c] = uint8((float32(val) * rateAsRaw)) | |
| wavInfo.Data.Sample[i].val8s[c] = uint8(clip) | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| //val := wavInfo.Data.Sample[i].val16s[c] | |
| //wavInfo.Data.Sample[i].val16s[c] = int16((float32(val) * rateAsRaw)) | |
| val := wavInfo.Data.Sample[i].val16s[c] | |
| clip := float64(val) * float64(rateAsRaw) | |
| if clip < MinInt16 { | |
| clip = MinInt16 | |
| } | |
| if clip > MaxInt16 { | |
| clip = MaxInt16 | |
| } | |
| wavInfo.Data.Sample[i].val16s[c] = int16(clip) | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val32s[c] | |
| wavInfo.Data.Sample[i].val32s[c] = val * rateAsRaw | |
| } | |
| } | |
| } | |
| } | |
| //Resample 重置采样率 | |
| func (wavInfo *WavInfoType) Resample(resampleRate uint32) { | |
| sampleRate := wavInfo.Fmt.SampleRate | |
| rate := float64(sampleRate) / float64(resampleRate) | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| rawLen := len(wavInfo.Data.Sample) | |
| resampleData := make([]SampleType, 0) | |
| resampleIdx := 0 | |
| for { | |
| rawIdx := int(float64(resampleIdx) * rate) | |
| if rawIdx < rawLen { | |
| sample := SampleType{} | |
| for c := 0; c < int(channel); c++ { | |
| switch bytePerSample { | |
| case 1: | |
| val := wavInfo.Data.Sample[rawIdx].val8s[c] | |
| //sample.val8s = append(sample.val8s,val) | |
| sample.val8s[c] = val | |
| case 2: | |
| val := wavInfo.Data.Sample[rawIdx].val16s[c] | |
| //sample.val16s = append(sample.val16s,val) | |
| sample.val16s[c] = val | |
| case 4: | |
| val := wavInfo.Data.Sample[rawIdx].val32s[c] | |
| //sample.val32s = append(sample.val32s,val) | |
| sample.val32s[c] = val | |
| } | |
| } | |
| resampleData = append(resampleData, sample) | |
| } else { | |
| break | |
| } | |
| resampleIdx++ | |
| } | |
| wavInfo.Data.Sample = resampleData | |
| wavInfo.Fmt.SampleRate = resampleRate | |
| } | |
| //ConvertToFloat32 将采样值转换到 0 到 1 之间 | |
| func (wavInfo *WavInfoType) GetFloat32Samples(channel int, bytePerSample int) []float32 { | |
| //fmt.Println(wavInfo.cha) | |
| var floatSamples []float32 | |
| var point float32 | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| sample := &wavInfo.Data.Sample[i] | |
| switch bytePerSample { | |
| case 1: | |
| point = float32(sample.val8s[channel]) / (1 << 8) | |
| case 2: | |
| point = float32(sample.val16s[channel]) / (1 << 15) | |
| case 4: | |
| point = sample.val32s[channel] | |
| } | |
| floatSamples = append(floatSamples, point) | |
| } | |
| return floatSamples | |
| } | |
| //Trim 切头切尾 | |
| func (wavInfo *WavInfoType) Trim(dbPercent float32) { | |
| channel := wavInfo.Fmt.Channels | |
| bytePerSample := wavInfo.Fmt.BitsPerSample / 8 | |
| //blockSize := channel*bytePerSample | |
| const MaxUint8 = math.MaxUint8 | |
| const MinUint8 = 0 | |
| const MaxInt16 = math.MaxInt16 | |
| const MinInt16 = math.MinInt16 | |
| //trim head | |
| silenceHeadIdx := 0 //头部静音截止位置 | |
| done := false | |
| for i := 0; i < len(wavInfo.Data.Sample); i++ { | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val8s[c] | |
| if float32(val) > MaxUint8*dbPercent { | |
| silenceHeadIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val16s[c] | |
| if float32(val) > MaxInt16*dbPercent { | |
| silenceHeadIdx = i | |
| done = true | |
| break | |
| } | |
| if float32(val) < MinInt16*dbPercent { | |
| silenceHeadIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val32s[c] | |
| if float32(val) > math.MaxFloat32*dbPercent { | |
| silenceHeadIdx = i | |
| done = true | |
| break | |
| } | |
| if val < 0 && (-val > math.MaxFloat32*dbPercent) { | |
| silenceHeadIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| } | |
| if done { | |
| break | |
| } | |
| } | |
| //trim tail,截断尾部 | |
| silenceTailIdx := len(wavInfo.Data.Sample) - 1 //尾部静音截止位置 | |
| done = false | |
| for i := len(wavInfo.Data.Sample) - 1; i >= 0; i-- { | |
| switch bytePerSample { | |
| case 1: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val8s[c] | |
| if float32(val) > MaxUint8*dbPercent { | |
| silenceTailIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| case 2: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val16s[c] | |
| if val >= 0 && float32(val) > float32(MaxInt16*dbPercent) { | |
| silenceTailIdx = i | |
| done = true | |
| break | |
| } | |
| if val < 0 && float32(val) < float32(MinInt16*dbPercent) { | |
| silenceTailIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| case 4: | |
| for c := 0; c < int(channel); c++ { | |
| val := wavInfo.Data.Sample[i].val32s[c] | |
| if float32(val) > math.MaxFloat32*dbPercent { | |
| silenceTailIdx = i | |
| done = true | |
| break | |
| } | |
| if val < 0 && (-val > math.MaxFloat32*dbPercent) { | |
| silenceTailIdx = i | |
| done = true | |
| break | |
| } | |
| } | |
| } | |
| if done { | |
| break | |
| } | |
| } | |
| wavInfo.Data.Sample = wavInfo.Data.Sample[:silenceTailIdx] | |
| wavInfo.Data.Sample = wavInfo.Data.Sample[silenceHeadIdx:] | |
| } | |
| func (wavInfo *WavInfoType) TrimFirstWithTime(milliseconds int64) error{ | |
| sampleRate := wavInfo.Fmt.SampleRate | |
| sizeToTrim := int64(sampleRate) * milliseconds / 1000 | |
| if int(sizeToTrim) >= len(wavInfo.Data.Sample) { | |
| return errors.New("check time err") | |
| } | |
| wavInfo.Data.Sample = wavInfo.Data.Sample[sizeToTrim:] | |
| return nil | |
| } | |
| func (wavInfo *WavInfoType) GetWavTime() int { | |
| return int(math.Ceil(float64(len(wavInfo.Data.Sample)) / float64(wavInfo.Fmt.SampleRate))) | |
| } | |
| //NewWavInfo 新建一个wav操作实例 | |
| func NewWavInfo() *WavInfoType { | |
| w := &WavInfoType{} | |
| return w | |
| } | |