Android ilbc 语音对话示范（四）发送方代码

上一文章中提到：
发送端有三个主要的类：AudioRecorder(负责音频采集），AudioEncoder(负责音频编码），AudioSender(负责 将编码后的数据发送出去）； 这三个类中各有一个线程，录制开始后，这三个线程一起运行，分别执行各自的任务， AudioRecorder采集音频后，添加到AudioEncoder 的音频数据的List中，而AudioEncoder 的编码线程不断从List头部取出数据，调用 ilbc 的底层\函数进行编码，编码后的数据则又添加到下一级的AudioSender的 List中，AudioSender又不断从头部取出数据，然后发送出去；

1. 先建立一个 AudioData的类，代表一段音频数据：

1. 
   
2. 
   
3. public class AudioData {   
   
4.     int size;   
   
5.     byte[] realData;   
   
6.     //long timestamp;   
   
7.     
   
8.     public int getSize() {   
   
9.         return size;   
   
10.     }   
    
11.     
    
12.     public void setSize(int size) {   
    
13.         this.size = size;   
    
14.     }   
    
15.     
    
16.     public byte[] getRealData() {   
    
17.         return realData;   
    
18.     }   
    
19.     
    
20.     public void setRealData(byte[] realData) {   
    
21.         this.realData = realData;   
    
22.     }   
    
23.     
    
24.     //public long getTimestamp() {   
    
25.     // return timestamp;   
    
26.     // }   
    
27.     //   
    
28.     // public void setTimestamp(long timestamp) {   
    
29.     // this.timestamp = timestamp;   
    
30.     // }   
    
31. }
    
32. 
    

复制代码

2. AudioRecorder 类，使用Android系统自带的AudioRecord来采集音频，每采集一次，就交给编码器编码。

1. 
   
2. 
   
3. public class AudioRecorder implements Runnable {   
   
4.     
   
5.     String LOG = "Recorder ";   
   
6.     
   
7.     private boolean isRecording = false;   
   
8.     private AudioRecord audioRecord;   
   
9.     
   
10.     private static final int audioSource = MediaRecorder.AudioSource.MIC;   
    
11.     private static final int sampleRate = 8000;   
    
12.     private static final int channelConfig = AudioFormat.CHANNEL_IN_MONO;   
    
13.     private static final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;   
    
14.     private static final int BUFFER_FRAME_SIZE =960;   
    
15.     private int audioBufSize = 0;   
    
16.     
    
17.     //   
    
18.     private byte[] samples;// 缓冲区   
    
19.     private int bufferRead = 0;// 从recorder中读取的samples的大小   
    
20.     
    
21.     private int bufferSize = 0;// samples的大小   
    
22.     
    
23.     // 开始录制   
    
24.     public void startRecording() {   
    
25.         bufferSize = BUFFER_FRAME_SIZE;   
    
26.     
    
27.         audioBufSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig,   
    
28.                 audioFormat);   
    
29.         if (audioBufSize == AudioRecord.ERROR_BAD_VALUE) {   
    
30.             Log.e(LOG, "audioBufSize error");   
    
31.             return;   
    
32.         }   
    
33.         samples = new byte[audioBufSize];   
    
34.         // 初始化recorder   
    
35.         if (null == audioRecord) {   
    
36.             audioRecord = new AudioRecord(audioSource, sampleRate,   
    
37.                     channelConfig, audioFormat, audioBufSize);   
    
38.         }   
    
39.         new Thread(this).start();   
    
40.     }   
    
41.     
    
42.     // 停止录制   
    
43.     public void stopRecording() {   
    
44.         this.isRecording = false;   
    
45.     }   
    
46.     
    
47.     public boolean isRecording() {   
    
48.         return isRecording;   
    
49.     }   
    
50.     
    
51.     // run   
    
52.     public void run() {   
    
53.         // 录制前，先启动解码器   
    
54.         AudioEncoder encoder = AudioEncoder.getInstance();   
    
55.         encoder.startEncoding();   
    
56.     
    
57.         System.out.println(LOG + "audioRecord startRecording()");   
    
58.         audioRecord.startRecording();   
    
59.     
    
60.         this.isRecording = true;   
    
61.         while (isRecording) {   
    
62.             bufferRead = audioRecord.read(samples, 0, bufferSize);   
    
63.             if (bufferRead > 0) {   
    
64.                 // 将数据添加给解码器   
    
65.                 encoder.addData(samples, bufferRead);   
    
66.             }   
    
67.     
    
68.             try {   
    
69.                 Thread.sleep(20);   
    
70.             } catch (InterruptedException e) {   
    
71.                 e.printStackTrace();   
    
72.             }   
    
73.         }   
    
74.         System.out.println(LOG + "录制结束");   
    
75.         audioRecord.stop();   
    
76.         encoder.stopEncoding();   
    
77.     }   
    
78. }
    
79. 
    

复制代码

3.   AudioEncoder，负责调用NDK 方法实现音频的编码，每编码一次，就交给AudioSender 去发送：

1. 
   
2. 
   
3. public class AudioEncoder implements Runnable {   
   
4.     String LOG = "AudioEncoder";   
   
5.     
   
6.     private static AudioEncoder encoder;   
   
7.     private boolean isEncoding = false;   
   
8.     
   
9.     private List<AudioData> dataList = null;// 存放数据   
   
10.     
    
11.     public static AudioEncoder getInstance() {   
    
12.         if (encoder == null) {   
    
13.             encoder = new AudioEncoder();   
    
14.         }   
    
15.         return encoder;   
    
16.     }   
    
17.     
    
18.     private AudioEncoder() {   
    
19.         dataList = Collections.synchronizedList(new LinkedList<AudioData>());   
    
20.     }   
    
21.     
    
22.     public void addData(byte[] data, int size) {   
    
23.         AudioData rawData = new AudioData();   
    
24.         rawData.setSize(size);   
    
25.         byte[] tempData = new byte[size];   
    
26.         System.arraycopy(data, 0, tempData, 0, size);   
    
27.         rawData.setRealData(tempData);   
    
28.         dataList.add(rawData);   
    
29.     }   
    
30.     
    
31.     // 开始编码   
    
32.     public void startEncoding() {   
    
33.         System.out.println(LOG + "解码线程启动");   
    
34.         if (isEncoding) {   
    
35.             Log.e(LOG, "编码器已经启动，不能再次启动");   
    
36.             return;   
    
37.         }   
    
38.         new Thread(this).start();   
    
39.     }   
    
40.     
    
41.     // 结束   
    
42.     public void stopEncoding() {   
    
43.         this.isEncoding = false;   
    
44.     }   
    
45.     
    
46.     public void run() {   
    
47.         // 先启动发送端   
    
48.         AudioSender sender = new AudioSender();   
    
49.         sender.startSending();   
    
50.     
    
51.         int encodeSize = 0;   
    
52.         byte[] encodedData = new byte[256];   
    
53.     
    
54.         // 初始化编码器   
    
55.         AudioCodec.audio_codec_init(30);   
    
56.     
    
57.         isEncoding = true;   
    
58.         while (isEncoding) {   
    
59.             if (dataList.size() == 0) {   
    
60.                 try {   
    
61.                     Thread.sleep(20);   
    
62.                 } catch (InterruptedException e) {   
    
63.                     e.printStackTrace();   
    
64.                 }   
    
65.                 continue;   
    
66.             }   
    
67.             if (isEncoding) {   
    
68.                 AudioData rawData = dataList.remove(0);   
    
69.                 encodedData = new byte[rawData.getSize()];   
    
70.                 //   
    
71.                 encodeSize = AudioCodec.audio_encode(rawData.getRealData(), 0,   
    
72.                         rawData.getSize(), encodedData, 0);   
    
73.                 System.out.println();   
    
74.                 if (encodeSize > 0) {   
    
75.                     sender.addData(encodedData, encodeSize);   
    
76.                     // 清空数据   
    
77.                     encodedData = new byte[encodedData.length];   
    
78.                 }   
    
79.             }   
    
80.         }   
    
81.         System.out.println(LOG + "编码结束");   
    
82.         sender.stopSending();   
    
83.     }   
    
84. }
    
85. 
    

复制代码

4.  AudioSender类，负责音频数据的发送，使用UDP协议将编码后的AMR音频数据发送到服务器端，这个类功能简单：

1. 
   
2. 
   
3. public class AudioSender implements Runnable {   
   
4.     String LOG = "AudioSender ";   
   
5.     
   
6.     private boolean isSendering = false;   
   
7.     private List<AudioData> dataList;   
   
8.     
   
9.     DatagramSocket socket;   
   
10.     DatagramPacket dataPacket;   
    
11.     private InetAddress ip;   
    
12.     private int port;   
    
13.     
    
14.     public AudioSender() {   
    
15.         dataList = Collections.synchronizedList(new LinkedList<AudioData>());   
    
16.         try {   
    
17.             try {   
    
18.                 ip = InetAddress.getByName(MyConfig.SERVER_HOST);   
    
19.                 this.port = MyConfig.SERVER_PORT;   
    
20.                 socket = new DatagramSocket();   
    
21.             } catch (UnknownHostException e) {   
    
22.                 e.printStackTrace();   
    
23.             }   
    
24.         } catch (SocketException e) {   
    
25.             e.printStackTrace();   
    
26.         }   
    
27.     }   
    
28.     
    
29.     // 添加数据   
    
30.     public void addData(byte[] data, int size) {   
    
31.         AudioData encodedData = new AudioData();   
    
32.         encodedData.setSize(size);   
    
33.         byte[] tempData = new byte[size];   
    
34.         System.arraycopy(data, 0, tempData, 0, size);   
    
35.         encodedData.setRealData(tempData);   
    
36.         dataList.add(encodedData);   
    
37.     }   
    
38.     
    
39.     // 发送数据   
    
40.     private void sendData(byte[] data, int size) {   
    
41.         try {   
    
42.             dataPacket = new DatagramPacket(data, size, ip, port);   
    
43.             dataPacket.setData(data);   
    
44.             socket.send(dataPacket);   
    
45.         } catch (IOException e) {   
    
46.             e.printStackTrace();   
    
47.         }   
    
48.     }   
    
49.     
    
50.     // 开始发送   
    
51.     public void startSending() {   
    
52.         System.out.println(LOG + "发送线程启动");   
    
53.         new Thread(this).start();   
    
54.     }   
    
55.     
    
56.     // 停止发送   
    
57.     public void stopSending() {   
    
58.         this.isSendering = false;   
    
59.     }   
    
60.     
    
61.     // run   
    
62.     public void run() {   
    
63.         this.isSendering = true;   
    
64.         System.out.println(LOG + "开始发送数据");   
    
65.         while (isSendering) {   
    
66.             if (dataList.size() > 0) {   
    
67.                 AudioData encodedData = dataList.remove(0);   
    
68.                 sendData(encodedData.getRealData(), encodedData.getSize());   
    
69.             }   
    
70.         }   
    
71.         System.out.println(LOG + "发送结束");   
    
72.     }   
    
73. }
    
74. 
    

复制代码

5.   另外，上述类中有一个 MyConfig 类，主要放一些 配置参数：

1. 
   
2. 
   
3. public class MyConfig {   
   
4.     public static String SERVER_HOST = "192.168.1.130";// 服务器的IP   
   
5.     public static final int SERVER_PORT = 5656;// 服务器的监听端口   
   
6.     public static final int CLIENT_PORT = 5757;//   
   
7.     
   
8.     public static final int AUDIO_STATUS_RECORDING = 0;//手机端的状态：录音 or 播放   
   
9.     public static final int AUDIO_STATUS_LISTENING = 1;   
   
10.     
    
11.     public static void setServerHost(String ip) {   
    
12.         System.out.println("修改后的服务器网址为  " + ip);   
    
13.         SERVER_HOST = ip;   
    
14.     }   
    
15. }
    
16. 
    

复制代码

上述代码实现了发送端的功能，现在代码结构如下：
 

本实例中对音频没有添加时间戳处理，实际测试中没有太大的影响，可以听的清楚双方的语音对话，如果想要添加时间戳的话，就在音频录制 AudioRecord的 read方法出得到时间戳，然后附加给UDP包。 取自： http://www.cnblogs.com/swordbearer/archive/2012/08/10/2633083.html