Android ilbc 语音对话示范（五）接收端处理

 

如上图所示，接收方的操作有三个类：AudioDecoder(负责解码），AudioPlayer(负责播放解码后的音频），AudioReceiver(负责从服务器接收音频数据包），这三个类的流程在第三篇中有详细的介绍。1.AudioReceiver代码：
   AudioReceiver使用UDP方式从服务端接收音频数据，其过程比较简单，直接上代码：

1. 
   
2. View Code 
   
3. package xmu.swordbearer.audio.receiver;
   
4. import java.io.IOException;
   
5. import java.net.DatagramPacket;
   
6. import java.net.DatagramSocket;
   
7. import java.net.SocketException;
   
8. import xmu.swordbearer.audio.MyConfig;
   
9. import android.util.Log;
   
10. public class AudioReceiver implements Runnable {
    
11.     String LOG = "NET Reciever ";
    
12.     int port = MyConfig.CLIENT_PORT;// 接收的端口
    
13.     DatagramSocket socket;
    
14.     DatagramPacket packet;
    
15.     boolean isRunning = false;
    
16.     private byte[] packetBuf = new byte[1024];
    
17.     private int packetSize = 1024;
    
18.     /*
    
19.      * 开始接收数据
    
20.      */
    
21.     public void startRecieving() {
    
22.         if (socket == null) {
    
23.             try {
    
24.                 socket = new DatagramSocket(port);
    
25.                 packet = new DatagramPacket(packetBuf, packetSize);
    
26.             } catch (SocketException e) {
    
27.             }
    
28.         }
    
29.         new Thread(this).start();
    
30.     }
    
31.     /*
    
32.      * 停止接收数据
    
33.      */
    
34.     public void stopRecieving() {
    
35.         isRunning = false;
    
36.     }
    
37.     /*
    
38.      * 释放资源
    
39.      */
    
40.     private void release() {
    
41.         if (packet != null) {
    
42.             packet = null;
    
43.         }
    
44.         if (socket != null) {
    
45.             socket.close();
    
46.             socket = null;
    
47.         }
    
48.     }
    
49.     public void run() {
    
50.         // 在接收前，要先启动解码器
    
51.         AudioDecoder decoder = AudioDecoder.getInstance();
    
52.         decoder.startDecoding();
    
53.         isRunning = true;
    
54.         try {
    
55.             while (isRunning) {
    
56.                 socket.receive(packet);
    
57.                 // 每接收一个UDP包，就交给解码器，等待解码
    
58.                 decoder.addData(packet.getData(), packet.getLength());
    
59.             }
    
60.         } catch (IOException e) {
    
61.             Log.e(LOG, LOG + "RECIEVE ERROR!");
    
62.         }
    
63.         // 接收完成，停止解码器，释放资源
    
64.         decoder.stopDecoding();
    
65.         release();
    
66.         Log.e(LOG, LOG + "stop recieving");
    
67.     }
    
68. }
    

复制代码

2.AudioDecoder代码：

解码的过程也很简单，由于接收端接收到了音频数据，然后就把数据交给解码器，所以解码的主要工作就是把接收端的数据取出来进行解码，如果解码正确，就将解码后的数据再转交给AudioPlayer去播放，这三个类之间是依次传递的 :
AudioReceiver---->AudioDecoder--->AudioPlayer

下面代码中有个List变量 private List<AudioData> dataList = null;这个就是用来存放数据的，每次解码时，dataList.remove(0)，从最前端取出数据进行解码：

1. 
   
2. View Code 
   
3. package xmu.swordbearer.audio.receiver;  
   
4.    
   
5. import java.util.Collections;  
   
6. import java.util.LinkedList;  
   
7. import java.util.List;  
   
8.    
   
9. import xmu.swordbearer.audio.AudioCodec;  
   
10. import xmu.swordbearer.audio.data.AudioData;  
    
11. import android.util.Log;  
    
12.    
    
13. public class AudioDecoder implements Runnable {  
    
14.    
    
15.      String LOG = "CODEC Decoder ";  
    
16.      private static AudioDecoder decoder;  
    
17.    
    
18.      private static final int MAX_BUFFER_SIZE = 2048;  
    
19.    
    
20.      private byte[] decodedData = new byte[1024];// data of decoded  
    
21.      private boolean isDecoding = false;  
    
22.      private List<AudioData> dataList = null;  
    
23.    
    
24.      public static AudioDecoder getInstance() {  
    
25.          if (decoder == null) {  
    
26.              decoder = new AudioDecoder();  
    
27.          }  
    
28.          return decoder;  
    
29.      }  
    
30.    
    
31.      private AudioDecoder() {  
    
32.          this.dataList = Collections  
    
33.                  .synchronizedList(new LinkedList<AudioData>());  
    
34.      }  
    
35.    
    
36.      /* 
    
37.       * add Data to be decoded 
    
38.       *  
    
39.       * @ data:the data recieved from server 
    
40.       *  
    
41.       * @ size:data size 
    
42.       */  
    
43.      public void addData(byte[] data, int size) {  
    
44.          AudioData adata = new AudioData();  
    
45.          adata.setSize(size);  
    
46.          byte[] tempData = new byte[size];  
    
47.          System.arraycopy(data, 0, tempData, 0, size);  
    
48.          adata.setRealData(tempData);  
    
49.          dataList.add(adata);  
    
50.          System.out.println(LOG + "add data once");  
    
51.    
    
52.      }  
    
53.    
    
54.      /* 
    
55.       * start decode AMR data 
    
56.       */  
    
57.      public void startDecoding() {  
    
58.          System.out.println(LOG + "start decoder");  
    
59.          if (isDecoding) {  
    
60.              return;  
    
61.          }  
    
62.          new Thread(this).start();  
    
63.      }  
    
64.    
    
65.      public void run() {  
    
66.          // start player first  
    
67.          AudioPlayer player = AudioPlayer.getInstance();  
    
68.          player.startPlaying();  
    
69.          //  
    
70.          this.isDecoding = true;  
    
71.          // init ILBC parameter:30 ,20, 15  
    
72.          AudioCodec.audio_codec_init(30);  
    
73.    
    
74.          Log.d(LOG, LOG + "initialized decoder");  
    
75.          int decodeSize = 0;  
    
76.          while (isDecoding) {  
    
77.              while (dataList.size() > 0) {  
    
78.                  AudioData encodedData = dataList.remove(0);  
    
79.                  decodedData = new byte[MAX_BUFFER_SIZE];  
    
80.    
    
81.                  byte[] data = encodedData.getRealData();  
    
82.                  //  
    
83.                  decodeSize = AudioCodec.audio_decode(data, 0,  
    
84.                          encodedData.getSize(), decodedData, 0);  
    
85.                  if (decodeSize > 0) {  
    
86.                      // add decoded audio to player  
    
87.                      player.addData(decodedData, decodeSize);  
    
88.                      // clear data  
    
89.                      decodedData = new byte[decodedData.length];  
    
90.                  }  
    
91.              }  
    
92.          }  
    
93.          System.out.println(LOG + "stop decoder");  
    
94.          // stop playback audio  
    
95.          player.stopPlaying();  
    
96.      }  
    
97.    
    
98.      public void stopDecoding() {  
    
99.          this.isDecoding = false;  
    
100.      }  
     
101. }
     

复制代码

3.AudioPlayer代码：
播放器的工作流程其实和解码器一模一样，都是启动一个线程，然后不断从自己的 dataList中提取数据。不过要注意，播放器的一些参数配置非常的关键；

播放声音时，使用了Android自带的 AudioTrack 这个类，它有这个方法：
public int write(byte[] audioData,int offsetInBytes, int sizeInBytes)可以直接播放；

所有播放器的代码如下：

1. 
   
2. View Code 
   
3. package xmu.swordbearer.audio.receiver;
   
4. 
   
5. import java.util.Collections;
   
6. import java.util.LinkedList;
   
7. import java.util.List;
   
8. 
   
9. import xmu.swordbearer.audio.data.AudioData;
   
10. import android.media.AudioFormat;
    
11. import android.media.AudioManager;
    
12. import android.media.AudioRecord;
    
13. import android.media.AudioTrack;
    
14. import android.util.Log;
    
15. 
    
16. public class AudioPlayer implements Runnable {
    
17.      String LOG = "AudioPlayer ";
    
18.      private static AudioPlayer player;
    
19. 
    
20.      private List<AudioData> dataList = null;
    
21.      private AudioData playData;
    
22.      private boolean isPlaying = false;
    
23. 
    
24.      private AudioTrack audioTrack;
    
25. 
    
26.      private static final int sampleRate = 8000;
    
27.      // 注意：参数配置
    
28.      private static final int channelConfig = AudioFormat.CHANNEL_IN_MONO;
    
29.      private static final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
    
30. 
    
31.      private AudioPlayer() {
    
32.          dataList = Collections.synchronizedList(new LinkedList<AudioData>());
    
33.      }
    
34. 
    
35.      public static AudioPlayer getInstance() {
    
36.          if (player == null) {
    
37.              player = new AudioPlayer();
    
38.          }
    
39.          return player;
    
40.      }
    
41. 
    
42.      public void addData(byte[] rawData, int size) {
    
43.          AudioData decodedData = new AudioData();
    
44.          decodedData.setSize(size);
    
45. 
    
46.          byte[] tempData = new byte[size];
    
47.          System.arraycopy(rawData, 0, tempData, 0, size);
    
48.          decodedData.setRealData(tempData);
    
49.          dataList.add(decodedData);
    
50.      }
    
51. 
    
52.      /*
    
53.       * init Player parameters
    
54.       */
    
55.      private boolean initAudioTrack() {
    
56.          int bufferSize = AudioRecord.getMinBufferSize(sampleRate,
    
57.                  channelConfig, audioFormat);
    
58.          if (bufferSize < 0) {
    
59.              Log.e(LOG, LOG + "initialize error!");
    
60.              return false;
    
61.          }
    
62.          audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
    
63.                  channelConfig, audioFormat, bufferSize, AudioTrack.MODE_STREAM);
    
64.          // set volume:设置播放音量
    
65.          audioTrack.setStereoVolume(1.0f, 1.0f);
    
66.          audioTrack.play();
    
67.          return true;
    
68.      }
    
69. 
    
70.      private void playFromList() {
    
71.          while (dataList.size() > 0 && isPlaying) {
    
72.              playData = dataList.remove(0);
    
73.              audioTrack.write(playData.getRealData(), 0, playData.getSize());
    
74.          }
    
75.      }
    
76. 
    
77.      public void startPlaying() {
    
78.          if (isPlaying) {
    
79.              return;
    
80.          }
    
81.          new Thread(this).start();
    
82.      }
    
83. 
    
84.      public void run() {
    
85.          this.isPlaying = true;
    
86.          
    
87.          if (!initAudioTrack()) {
    
88.              Log.e(LOG, LOG + "initialized player error!");
    
89.              return;
    
90.          }
    
91.          while (isPlaying) {
    
92.              if (dataList.size() > 0) {
    
93.                  playFromList();
    
94.              } else {
    
95.                  try {
    
96.                      Thread.sleep(20);
    
97.                  } catch (InterruptedException e) {
    
98.                  }
    
99.              }
    
100.          }
     
101.          if (this.audioTrack != null) {
     
102.              if (this.audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) {
     
103.                  this.audioTrack.stop();
     
104.                  this.audioTrack.release();
     
105.              }
     
106.          }
     
107.          Log.d(LOG, LOG + "end playing");
     
108.      }
     
109. 
     
110.      public void stopPlaying() {
     
111.          this.isPlaying = false;
     
112.      }
     
113. }
     

复制代码

4.简易服务端：

为了方便测试，我自己用Java 写了一个UDP的服务器，其功能非常的弱，就是接收，然后转发给另一方：

1. 
   
2. View Code 
   
3. import java.io.IOException;
   
4. import java.net.DatagramPacket;
   
5. import java.net.DatagramSocket;
   
6. import java.net.InetAddress;
   
7. import java.net.SocketException;
   
8. import java.net.UnknownHostException;
   
9. 
   
10. public class AudioServer implements Runnable {
    
11. 
    
12.      DatagramSocket socket;
    
13.      DatagramPacket packet;// 从客户端接收到的UDP包
    
14.      DatagramPacket sendPkt;// 转发给另一个客户端的UDP包
    
15. 
    
16.      byte[] pktBuffer = new byte[1024];
    
17.      int bufferSize = 1024;
    
18.      boolean isRunning = false;
    
19.      int myport = 5656;
    
20. 
    
21.      // ///////////
    
22.      String clientIpStr = "192.168.1.104";
    
23.      InetAddress clientIp;
    
24.      int clientPort = 5757;
    
25. 
    
26.      public AudioServer() {
    
27.          try {
    
28.              clientIp = InetAddress.getByName(clientIpStr);
    
29.          } catch (UnknownHostException e1) {
    
30.              e1.printStackTrace();
    
31.          }
    
32.          try {
    
33.              socket = new DatagramSocket(myport);
    
34.              packet = new DatagramPacket(pktBuffer, bufferSize);
    
35.          } catch (SocketException e) {
    
36.              e.printStackTrace();
    
37.          }
    
38.          System.out.println("服务器初始化完成");
    
39.      }
    
40. 
    
41.      public void startServer() {
    
42.          this.isRunning = true;
    
43.          new Thread(this).start();
    
44.      }
    
45. 
    
46.      public void run() {
    
47.          try {
    
48.              while (isRunning) {
    
49.                  socket.receive(packet);
    
50.                  sendPkt = new DatagramPacket(packet.getData(),
    
51.                          packet.getLength(), packet.getAddress(), clientPort);
    
52.                  socket.send(sendPkt);
    
53.                  try {
    
54.                      Thread.sleep(20);
    
55.                  } catch (InterruptedException e) {
    
56.                      e.printStackTrace();
    
57.                  }
    
58.              }
    
59.          } catch (IOException e) {
    
60.          }
    
61.      }
    
62. 
    
63.      // main
    
64.      public static void main(String[] args) {
    
65.          new AudioServer().startServer();
    
66.      }
    
67. }
    

复制代码

5.结语：

Android使用 ILBC 进行语音通话的大致过程就讲述完了，此系列只是做一个ILBC 使用原理的介绍，距离真正的语音通话还有很多工作要做，缺点还是很多的：

   1. 文章中介绍的只是单方通话，如果要做成双方互相通话或者一对多的通话，就需要增加更多的流程处理，其服务端也要做很多工作；

   2. 实时性：本程序在局域网中使用时，实时性还是较高的，但是再广域网中，效果可能会有所下降，除此之外，本程序还缺少时间戳的处理，如果网络状况不理想，或者数据延迟，就会导致语音播放前后混乱；

   3. 服务器很弱：真正的流媒体服务器，需要很强的功能，来对数据进行处理，我是为了方便，就写了一个简单的，最近打算移植live555，用来做专门的流媒体服务器，用RTP协议对数据进行封装，这样效果应该会好很多。

取自： http://www.cnblogs.com/swordbearer/archive/2012/10/17/2662164.html