首页 文章 精选 留言 我的

Golang 基于chrome浏览器语音识别web演示系统WebHTK开发之 HTML5 录音篇

2017-11-14 701

   学院与科大讯飞合作“厦门大学-科大讯飞闽南语语音与语言联合实验室”，第一阶段的语音识别演示系统，可能只是简单的闽南语孤立词识别。现成的演示系统有去年写的android演示程序。打算再写个PC端的演示系统，基本的引擎已经搭建好，后续界面和数据库方面再调整优化。再来，最近学习Golang，怎么可以不用上呢？web版演示系统，golang（Beego框架）（后端） + HTML5（前端） + MongoDB（数据库）。

   本节，主要讲解web前端的录音工作，以及通过HTML5 websocket传输音频流数据到后端并保存。

来看下代码：

   record.html:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
<!DOCTYPE HTML>
<html lang= "en" >
     <head>
         <meta charset =  "utf-8" />
         <title>PONPON Chat by WebSockets</title>
         <script type= "text/javascript"  src= "/static/lib/recorder.js" > </script>
         <script type= "text/javascript"  src= "/static/lib/jquery-1.10.1.min.js" > </script>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
         <style type= 'text/css' >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
         </style>
     </head>
     <body>
         <audio controls autoplay></audio>
       <form>
        <input type= "button"  id= "record"  value= "录音" >
        <input type= "button"  id= "export"  value= "发送" >
        </form>
        <div id= "message" ></div>
     </body>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
     <script type= 'text/javascript' >
             //回调函数
             var  onFail =  function (e) {
                 console.log( 'Rejected!' , e);
             };                                                                                                                                                                                                                 //回调函数                                       
             var  onSuccess =  function (s) {
                 var  context =  new  webkitAudioContext();
                 var  mediaStreamSource = context.createMediaStreamSource(s);
                 rec =  new  Recorder(mediaStreamSource);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
             //window.URL = URL || window.URL || window.webkitURL;
             navigator.getUserMedia  = navigator.getUserMedia ||
navigator.webkitGetUserMedia || navigator.mozGetUserMedia ||
navigator.msGetUserMedia;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
             var  rec;
             var  audio = document.querySelector( '#audio' );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
             function  startRecording() {
                 if  (navigator.getUserMedia) {
         //onSuccess, onFail分别为getUserMedia成功或失败的回调函数
                     navigator.getUserMedia({audio:  true }, onSuccess, onFail);
                 }  else  {
                     console.log( 'navigator.getUserMedia not present' );
                 }
             }
             startRecording();
             //--------------------
             $( '#record' ).click( function () {
                 rec.record();
                var  dd = ws.send( "start" );
                 $( "#message" ).text( "Click export to stop recording" );
                                                                                                                                                                                                                                                         
                 /*
                   setInterval函数，看到后面3000没？意思是周期为3000毫
                   秒，每过3000毫秒，执行一次前面的function，在此处就是
                   执行function内的rec.clear()和ws.send(blob),直到
                   clearInterval(intervalKey)函数出现则停止
                  */
                 intervalKey = setInterval( function () {
                     rec.exportWAV( function (blob) {          
                         rec.clear();
                         ws.send(blob);
                         //audio.src = URL.createObjectURL(blob);
                     });
                 }, 3000);
             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
             $( '#export' ).click( function () {
                 // first send the stop command
                 rec.stop();
                 ws.send( "stop" );
                 clearInterval(intervalKey);
                 $( "#message" ).text( "已发送到服务器！" );
             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
             var  ws =  new  WebSocket( 'ws://'  + window.location.host +  '/record/join' );
             ws.onopen =  function  () {
                 console.log( "Openened connection to websocket" );
             };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
             ws.onclose =  function  (){
                  console.log( "Close connection to websocket" );
             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
             ws.onerror =  function  (){
                 console.log( "Cannot connection to websocket" );
             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
             ws.onmessage =  function (e) {
                 audio.src = URL.createObjectURL(e.data);
             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
         </script>
</html>

   这段代码关键在于navigator.getUserMedia来获得客户端的媒体资源。进入该页面，将向chrome浏览器客户端请求媒体资源。请求成功后：

1
2
3
4
5
6
7
8
//创建webkitAudio资源
var  context =  new  webkitAudioContext();
                                                                                                                                                                                                                                                                                                                                                                                                                                                       
//创建媒体流
  var  mediaStreamSource = context.createMediaStreamSource(s);
                                                                                                                                                                                                                                                                                                                                                                                                                                                       
//录音实例
rec =  new  Recorder(mediaStreamSource);


  开始录音，执行rec.record()，看下recorder.js：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
( function (window) {
     var  WORKER_PATH =  '/static/lib/recorderWorker.js' ;
                                                                                                                                                                                                                                                                                                                                                                                                                                          
     var  Recorder =  function (source, cfg) {
         var  config = cfg || {};
         var  bufferLen = config.bufferLen || 4096*2;
         this .context = source.context;
         /*
          下面 createJavaScriptNode()中后两个参数分别为
          输入、输出声道数。1指单声道，2指多声道
         */
         this .node =  this .context.createJavaScriptNode(bufferLen, 2, 2);
         var  worker =  new  Worker(config.workerPath || WORKER_PATH);
         worker.postMessage({
             command:  'init' ,
             config: {
                 sampleRate:  this .context.sampleRate
             }
         });
         var  recording =  false ,
             currCallback;
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .node.onaudioprocess =  function (e) {
             if  (!recording)  return ;
             worker.postMessage({
                 command:  'record' ,
                 buffer: [
                     //获得左声道数据
                     e.inputBuffer.getChannelData(0)
                     ,
                     //获得右声道数据
                     e.inputBuffer.getChannelData(1)
                 ]
             });
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .configure =  function (cfg) {
             for  ( var  prop  in  cfg) {
                 if  (cfg.hasOwnProperty(prop)) {
                     config[prop] = cfg[prop];
                 }
             }
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .record =  function () {
             recording =  true ;
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .stop =  function () {
             recording =  false ;
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .clear =  function () {
                                                                                                                                                                                                                                                                                                                                                                                                                                          
             worker.postMessage({
                 command:  'clear'
             });
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .getBuffer =  function (cb) {
             currCallback = cb || config.callback;
             worker.postMessage({
                 command:  'getBuffer'
             })
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         this .exportWAV =  function (cb, type) {
             currCallback = cb || config.callback;
             type = type || config.type ||  'audio/wav' ;
             if  (!currCallback)  throw  new  Error( 'Callback not set' );
             worker.postMessage({
                 command:  'exportWAV' ,
                 type: type
             });
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         worker.onmessage =  function (e) {
             var  blob = e.data;
             currCallback(blob);
         }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
         source.connect( this .node);
         this .node.connect( this .context.destination);  //this should not be necessary
     };
                                                                                                                                                                                                                                                                                                                                                                                                                                          
     Recorder.forceDownload =  function (blob, filename) {
         var  url = (window.URL || window.webkitURL).createObjectURL(blob);
         alert(url);
         var  link = window.document.createElement( 'a' );
         link.href = url;
         link.download = filename ||  'output.wav' ;
         var  click = document.createEvent( "Event" );
         click.initEvent( "click" ,  true ,  true );
         link.dispatchEvent(click);
     }
                                                                                                                                                                                                                                                                                                                                                                                                                                          
     window.Recorder = Recorder;
                                                                                                                                                                                                                                                                                                                                                                                                                                          
})(window);

   开始录音后，执行this.node.onaudioprocess，从录音缓冲去录音samples数据，注意：

1
2
3
4
5
6
7
8
worker.postMessage({
                 command:  'record' ,
                 buffer: [
                     e.inputBuffer.getChannelData(0)
                     ,
                     e.inputBuffer.getChannelData(1)
                 ]
             });


  buffer将从录音设备获取两个声道的数据。


  recorderWorker.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
var  recLength = 0,
     recBuffersL = [],
     recBuffersR = [],
     sampleRate;
                                                                                                                                                                                                                                                                                                                                                                                                   
this .onmessage =  function (e) {
     switch  (e.data.command) {
         case  'init' :
             init(e.data.config);
             break ;
         case  'record' :
             record(e.data.buffer);
             break ;
         case  'exportWAV' :
             exportWAV(e.data.type);
             break ;
         case  'getBuffer' :
             getBuffer();
             break ;
         case  'clear' :
             clear();
             break ;
     }
};
                                                                                                                                                                                                                                                                                                                                                                                                    
function  init(config) {
     sampleRate = config.sampleRate ;
}
                                                                                                                                                                                                                                                                                                                                                                                                    
//从录音设备获得两个声道的数据
function  record(inputBuffer) {
     recBuffersL.push(inputBuffer[0]);
     recBuffersR.push(inputBuffer[1]);
     recLength += inputBuffer[0].length;
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//发送处理好的dataview数据
function  exportWAV(type) {
     var  bufferL = mergeBuffers(recBuffersL, recLength);
     var  bufferR = mergeBuffers(recBuffersR, recLength);
     var  interleaved = interleave(bufferL , bufferR);
     var  dataview = encodeWAV(interleaved);
     var  audioBlob =  new  Blob([dataview], {
         type: type
     });
     this .postMessage(audioBlob);
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//从录音缓冲读取数据存入发送缓冲
function  getBuffer() {
     var  buffers = [];
     buffers.push(mergeBuffers(recBuffersL, recLength));
     buffers.push( mergeBuffers(recBuffersR, recLength) );
     this .postMessage(buffers);
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//清除录音缓冲数据
function  clear(inputBuffer) {
     recLength = 0;
     recBuffersL = [];
     recBuffersR = [];
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//合并数据
function  mergeBuffers(recBuffers, recLength) {
     var  result =  new  Float32Array(recLength);
     var  offset = 0;
     for  ( var  i = 0; i < recBuffers.length; i++) {
         result.set(recBuffers[i], offset);
         offset += recBuffers[i].length;
     }
     return  result;
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//合并交错左右声道数据
function  interleave(inputL, inputR){
// function interleave(inputL) {
     var  length = inputL.length + inputR.length ;
     var  result =  new  Float32Array(length);
                                                                                                                                                                                                                                                                                                                                                                                                   
     var  index = 0,
         inputIndex = 0;
                                                                                                                                                                                                                                                                                                                                                                                                   
     while  (index < length) {
         result[index++] = inputL[inputIndex];
         result[index++] = inputR[inputIndex];
         inputIndex++;
     }
     return  result;
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//数据转码16bit
function  floatTo16BitPCM(output, offset, input) {
     for  ( var  i = 0; i < input.length; i++, offset += 2) {
         var  s = Math.max(-1, Math.min(1, input[i]));
         output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF,  true );
     }
}
                                                                                                                                                                                                                                                                                                                                                                                                   
function  writeString(view, offset, string) {
     for  ( var  i = 0; i < string.length; i++) {
         view.setUint8(offset + i, string.charCodeAt(i));
     }
}
                                                                                                                                                                                                                                                                                                                                                                                                   
//写入44位 wav数据头
function  encodeWAV(samples) {
                                                                                                                                                                                                                                                                                                                                                                                                     
     var  buffer =  new  ArrayBuffer(44 + samples.length * 2);
     var  view =  new  DataView(buffer);
                                                                                                                                                                                                                                                                                                                                                                                                   
     /* RIFF identifier */
     writeString(view, 0,  'RIFF' );
     /* file length */
     view.setUint32(4, 32 + samples.length * 2,  true );
     /* RIFF type */
     writeString(view, 8,  'WAVE' );
     /* format chunk identifier */
     writeString(view, 12,  'fmt ' );
     /* format chunk length */
     view.setUint32(16, 16,  true );
     /* sample format (raw) */
     view.setUint16(20, 1,  true );
     /* channel count */
     view.setUint16(22, 2,  true );
     /* sample rate */
     view.setUint32(24, sampleRate,  true );
     /* byte rate (sample rate * block align) */
     view.setUint32(28, sampleRate * 4,  true );
     /* block align (channel count * bytes per sample) */
     view.setUint16(32, 4,  true );
     /* bits per sample */
     view.setUint16(34, 16,  true );
     /* data chunk identifier */
     writeString(view, 36,  'data' );
     /* data chunk length */
     view.setUint32(40, samples.length * 2,  true );
     floatTo16BitPCM(view, 44, samples);
     return  view;
}

   目前,只能录制48000Hz 16Bit 数据。我调整了录制参数，所需目标格式为8000Hz 16Bit Mono语音数据，但是失败了，录制出的数据仍然是48000Hz  16Bit。由于对前端javascript代码完全不了解，后续再来研究怎么解决这个录音格式的问题。    

   补：录制单声道的话，在recorder.js中修改this.context.createJavaScriptNode(bufferLen, 1, 1)，在recorderWorker.js中把右声道的数据都砍掉就ok了。


  再回头看record.html中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//进入页面服务器发送websocket握手请求
var  ws =  new  WebSocket( 'ws://'  + window.location.host +  '/record/join' );
                                                                                                                                                                                                                                                                                                   
   //握手成功
    ws.onopen =  function  () {
          console.log( "Openened connection to websocket" );
    };
   //断开连接
    ws.onclose =  function  (){
          console.log( "Close connection to websocket" );
    }
   //握手失败
    ws.onerror =  function  (){
          console.log( "Cannot connection to websocket" );
    }


  每次刷新登入该页面，客户端就会向服务器发送websocket握手请求，握手成功后，js代码中录好音之后 将ws.send(数据)对应到button上，点击按钮就可发送数据了。

   golang beego框架后端怎么来处理数据呢？在页面对应的controllers上的代码上定义controller的join方法，代码较为简陋，初步实现功能，后续加上channel等来完善：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package  controllers
                                                                                                                                                                                                                                                    
import  (
     "bufio"
     "github.com/astaxie/beego"
     "github.com/garyburd/go-websocket/websocket"
     "net/http"
     "os"
     "path"
     "strings"
)
                                                                                                                                                                                                                                                    
type RecordController struct {
     beego.Controller
}
                                                                                                                                                                                                                                                    
func ( this  *RecordController) Join() {
     //获取请求端的IP地址
     remoteAddr := strings.Split( this .Ctx.Request.RemoteAddr,  ":" )[ 0 ]
     mlogger.i( "Reciving Record Data From Host: "  + remoteAddr)
                                                                                                                                                                                                                                               
     //获取websocket的连接实例
     ws, err := websocket.Upgrade( this .Ctx.ResponseWriter,  this .Ctx.Request.Header, nil,  1024 ,  1024 )
     if  _, ok := err.(websocket.HandshakeError); ok {
     http.Error( this .Ctx.ResponseWriter,  "Not a websocket handshake" ,  400 )
         return
     }  else  if  err != nil {
     beego.Error( "Cannot setup WebSocket connection:" , err)
     return
     }
                                                                                                                                                                                                                                                     
     //以IP地址作为保存wav文件的文件名
     wavName :=  "record/"  + remoteAddr +  ".wav"
                                                                                                                                                                                                                                                     
     os.MkdirAll(path.Dir(wavName), os.ModePerm)
     _, e := os.Stat(wavName)
     if  e == nil {
         //删除已有wav文件
         os.Remove(wavName)
     }
                                                                                                                                                                                                                                                    
     f, err := os.Create(wavName)
     mlogger.i( "Host:  "  + remoteAddr +  "  creating file handler  ..." )
     defer f.Close()
     if  err != nil {
         mlogger.e(err)
             return
     }
                                                                                                                                                                                                                                                    
     w := bufio.NewWriter(f)
                                                                                                                                                                                                                                                    
     for  {
     //从websocket上读取数据流
     _, p, err := ws.ReadMessage()
     if  err != nil {
         mlogger.i( "Host:  "  + remoteAddr +  "  disconnected ..." )
         break
     }
                                                                                                                                                                                                                                                    
     length := len(p)
                                                                                                                                                                                                                                                    
     if   length ==  4  || length ==  5  {
     //length == 4，说明在web上发送ws.send('stop')
     //length == 5，说明在web上发送ws.send('start')
                                                                                                                                                                                                                                       
         action := string(p)
         mlogger.i( "Client's action: "  + action +  " recording !" )
                                                                                                                                                                                                                                                               
             if  action ==  "stop"  {
         goto  SAVE
         }  else  {
         goto  RESTART
         }
     }
                                                                                                                                                                                                                                                    
     w.Write(p)
     continue
                                                                                                                                                                                                                                                    
SAVE:
     mlogger.i( "Host:  "  + remoteAddr +  "  saving wav file wav ..." )
     w.Flush()
     mlogger.i( "Host:  "  + remoteAddr +  "  flushing writer ..." )
     f.Close()
     mlogger.i( "Host:  "  + remoteAddr +  "  closing the file handler ..." )
     continue
                                                                                                                                                                                                                                                     
RESTART:
     os.Remove(wavName)
                                                                                                                                                                                                                                                    
     f, err = os.Create(wavName)
     mlogger.i( "Host:  "  + remoteAddr +  "  creating file handler  ..." )
     // defer f.Close()
     if  err != nil {
         mlogger.e(err)
         return
     }
                                                                                                                                                                                                                                                     
     w = bufio.NewWriter(f)
     }
     return
}

   在路由设置上：

1
2
beego.Router( "/record" , &controllers.RecordController{})
beego.Router( "/record/join" , &controllers.RecordController{},  "get:Join" )


   补：

   注意到在record.html中：

1
2
3
4
5
6
intervalKey = setInterval( function () {
rec.exportWAV( function (blob) {             
rec.clear();
ws.send(blob); 
});
}, 3000);

   setInterval函数中function里ws.send(blob)每过3秒就往服务器发送blob数据，在    recorderWorker.js中的encordWAV函数中，往裸语音数据数据加44位wav头数据，而数据的长度一直是本周期内所录语音数据的长度，这就会出现，最后在服务器保存了3秒以上的数据，但是读到的wav头中关于数据长度的值则只有3秒或3秒以内。并且，每次都往数据wav头也是不对的，44位wav并不是有效的语音数据。所以在recorderWorker.js中应修改encordWAV代码：

1
2
3
4
5
6
function  encodeWAV(samples) {
     var  buffer =  new  ArrayBuffer(samples.length * 2);
     var  view =  new  DataView(buffer);
     floatTo16BitPCM(view, 0, samples);
     return  view;
}


这样就直接往服务器传输裸语音数据流，在record.html上点击发送按钮的事件函数里，添加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$( '#export' ).click( function () {
                rec.stop();
                if  (intervalKey== null ) {
                $( "#message" ).text( "请先录音再发送！" );
                    return
                };
                 ws.send(sampleRate);
                     ws.send(channels);
                      console.log( 'sampleRate:' +sampleRate+ ',channels:' +channels);
                ws.send( "stop" );
                  rec.clear();
                clearInterval(intervalKey);
                $( "#message" ).text( "已发送到服务器！" );
            });


服务器就能收到收到数据的samplerate采样率，channels声道数。相应的在golang服务器代码join方法中，添加写44位wav头的代码，把这数据头写在裸语音数据缓存的最前端并保存wav文件即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
type wavHeader [] byte
                                    
//wav 44位文件头
func SetHeader(sampleRate  int , channel  int , length uint32) (header wavHeader) {
     header = make([] byte ,  44 )
                                    
     chunkSize := length +  36
     header[ 0 ] =  'R'
     header[ 1 ] =  'I'
     header[ 2 ] =  'F'
     header[ 3 ] =  'F'
     header[ 4 ] =  byte (chunkSize &  0xff )
     header[ 5 ] =  byte ((chunkSize >>  8 ) &  0xff )
     header[ 6 ] =  byte ((chunkSize >>  16 ) &  0xff )
     header[ 7 ] =  byte ((chunkSize >>  24 ) &  0xff )
     header[ 8 ] =  'W'
     header[ 9 ] =  'A'
     header[ 10 ] =  'V'
     header[ 11 ] =  'E'
     header[ 12 ] =  'f'
     header[ 13 ] =  'm'
     header[ 14 ] =  't'
     header[ 15 ] =  ' '
     header[ 16 ] =  16
     header[ 17 ] =  0
     header[ 18 ] =  0
     header[ 19 ] =  0
     header[ 20 ] =  1
     header[ 21 ] =  0
     header[ 22 ] =  byte (channel &  0xff )  //1 or 2
     header[ 23 ] =  0
     header[ 24 ] =  byte (sampleRate &  0xff )    //64 8000
     header[ 25 ] =  byte ((sampleRate >>  8 ) &  0xff )   //31 8000
     header[ 26 ] =  byte ((sampleRate >>  16 ) &  0xff )    //0
     header[ 27 ] =  byte ((sampleRate >>  24 ) &  0xff )    //0
     header[ 28 ] =  byte ((sampleRate *  2  * channel) &  0xff )  //128 800
     header[ 29 ] =  byte ((sampleRate *  2  * channel) >>  8  &  0xff )  //62
     header[ 30 ] =  byte ((sampleRate *  2  * channel) >>  16  &  0xff )  //0
     header[ 31 ] =  byte ((sampleRate *  2  * channel) >>  24  &  0xff )  //0
     header[ 32 ] =  byte ((channel *  2 ) &  0xff )        //2 or 4
     header[ 33 ] =  0
     header[ 34 ] =  16
     header[ 35 ] =  0
     header[ 36 ] =  'd'
     header[ 37 ] =  'a'
     header[ 38 ] =  't'
     header[ 39 ] =  'a'
     header[ 40 ] =  byte (length &  0xff )
     header[ 41 ] =  byte ((length >>  8 ) &  0xff )
     header[ 42 ] =  byte ((length >>  16 ) &  0xff )
     header[ 43 ] =  byte ((length >>  24 ) &  0xff )
                                    
     return
                                    
}


  如果需要去除语音的静音部分，参考我的github：github.com/liuxp0827/waveIO。最新的waveIO包没来得及上传，对delSilence函数做下修改即可。

   完整代码，请浏览附件：http://down.51cto.com/data/1092540。

   这样，从前端录音，到websocket传输数据，再到beego后端读写数据到服务器本地就可实现了    










本文转自 ponpon_ 51CTO博客，原文链接：http://blog.51cto.com/liuxp0827/1364435，如需转载请自行联系原作者
上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/481722

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

人工智能、深度学习、神经元网络常识

人工智能（Artificial Intelligence），英文缩写为AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。 人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种新的能以人类智能相似的方式做出反应的智能机器，该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。人工智能从诞生以来，理论和技术日益成熟，应用领域也不断扩大，可以设想，未来人工智能带来的科技产品，将会是人类智慧的“容器”。 人工智能是对人的意识、思维的信息过程的模拟。人工智能不是人的智能，但能像人那样思考、也可能超过人的智能。 人工智能是一门极富挑战性的科学，从事这项工作的人必须懂得计算机知识，心理学和哲学。人工智能是包括十分广泛的科学，它由不同的领域组成，如机器学习，计算机视觉等等，总的说来，人工智能研究的一个主要目标是使机器能够胜任一些通常需要人类智能才能完成的复杂工作。但不同的时代、不同的人对这种“复杂工作”的理解是不同的。 现在社会，信息量太大了，光靠人类，已经无法驾驭这些东西了，但是计算机本身只会按照死命令去分析数据，而无法真正...
2017-11-15
597
上一篇

图像识别DM8127开发攻略——开发环境搭建

经过两年的多爆炸性出货（针对我们这种小公司），目前稍微停顿了一下，现在难得有点时间继续写自己的博客，其实自己一直想静下心来做点东西，可惜做TI DAVINCI（ARM+DSP）这方面的人不太好招，本人这两年都一直在给大客户打杂，大批量生产，事情超级多，在《图像识别DM8127开发攻略——序》里面也提到这一点。对于这个ARM+DSP 的DM8127，我们还是从开发环境搭建开始写。 在写开发环境搭建之前，如果想知道我们为什么还要坚持做ARM+DSP方案，建议先看看本人写的《图像识别DM8127开发攻略——序》，在这里我们提到ARM+DSP（TI 通用型） 和ARM+FPGA，其实是从软件开发难度和使用角度去考虑选择的，毕竟大多数图像识别算法用C/C++都可以实现，移植到通用型DSP相对容易。以前在定点DSP C64+优化是一个大难题，现在DM8127提供浮点DSP，很多浮点运算就不要去转换成定点去运行了，DM8127的浮点运算能力达到4500M FLOPS，而且做产品的时候那些H264编解码JPEG编解码这些都不占用DSP的资源，有2个独立的HDVICP2处理。还有在实现同样复杂度的算法和...
2017-11-16
633
下一篇

相关文章

发表评论

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

时间: 2025-12-03 大小: 4.36MB 下载: 23次
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2025-12-12 大小: 211.28KB 下载: 54次
Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

时间: 2025-12-21 大小: 189MB 下载: 2次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
Nacos3 SpringBoot4 Gemini3 Kubernetes Jdk25 Docker DeepSeek HarmonyOS6 SpringCloud Redis OpenAi Rocky Service Mesh

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册