Android ilbc 语音对话示范（五）接收端处理【转】http://blog.youkuaiyun.com/ranxiedao/article/details/8080385...

最新推荐文章于 2021-08-10 11:39:23 发布

转载最新推荐文章于 2021-08-10 11:39:23 发布 · 74 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/songtzu/archive/2013/02/04/2891982.html

文章标签：

#移动开发 #java #网络

本文详细介绍Android平台下使用ILBC编码实现语音通话的具体步骤，包括接收端处理流程及核心代码解析。

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

分类： Android 语音对话 2012-10-17 12:32 483人阅读评论(5) 收藏举报

此系列文章拖了N久，有好多人发邮件来询问我第五次的文章为什么没有写，其实非常抱歉，本人学生一个，暑假一直

去公司实习，最近又忙着各种招聘找工作，没有时间好好写，现在抽空把最后一篇补上，水平有限，如过有不对的，请

各位指正～

前四篇文章分别介绍了 “代码结构”，“程序流程”，以及”发送方的处理”，现在就把接收方的处理流程做个介绍；

如上图所示，接收方的操作有三个类：AudioDecoder(负责解码），AudioPlayer(负责播放解码后的音频），

AudioReceiver(负责从服务器接收音频数据包），这三个类的流程在第三篇中有详细的介绍。

1.AudioReceiver代码：

AudioReceiver使用UDP方式从服务端接收音频数据，其过程比较简单，直接上代码：

package xmu.swordbearer.audio.receiver;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import xmu.swordbearer.audio.MyConfig;
import android.util.Log;
public class AudioReceiver implements Runnable {
String LOG = "NET Reciever ";
int port = MyConfig.CLIENT_PORT;// 接收的端口
DatagramSocket socket;
DatagramPacket packet;
boolean isRunning = false;
private byte[] packetBuf = new byte[1024];
private int packetSize = 1024;
/*
* 开始接收数据
*/
public void startRecieving() {
if (socket == null) {
try {
socket = new DatagramSocket(port);
packet = new DatagramPacket(packetBuf, packetSize);
} catch (SocketException e) {
}
}
new Thread(this).start();
}
/*
* 停止接收数据
*/
public void stopRecieving() {
isRunning = false;
}
/*
* 释放资源
*/
private void release() {
if (packet != null) {
packet = null;
}
if (socket != null) {
socket.close();
socket = null;
}
}
public void run() {
// 在接收前，要先启动解码器
AudioDecoder decoder = AudioDecoder.getInstance();
decoder.startDecoding();
isRunning = true;
try {
while (isRunning) {
socket.receive(packet);
// 每接收一个UDP包，就交给解码器，等待解码
decoder.addData(packet.getData(), packet.getLength());
}
} catch (IOException e) {
Log.e(LOG, LOG + "RECIEVE ERROR!");
}
// 接收完成，停止解码器，释放资源
decoder.stopDecoding();
release();
Log.e(LOG, LOG + "stop recieving");
}
}

2.AudioDecoder代码：

解码的过程也很简单，由于接收端接收到了音频数据，然后就把数据交给解码器，所以解码的主要工作就是把接收端的数

据取出来进行解码，如果解码正确，就将解码后的数据再转交给AudioPlayer去播放，这三个类之间是依次传递的 :

AudioReceiver---->AudioDecoder--->AudioPlayer

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

从最前端取出数据进行解码：

package xmu.swordbearer.audio.receiver;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import xmu.swordbearer.audio.AudioCodec;
import xmu.swordbearer.audio.data.AudioData;
import android.util.Log;
public class AudioDecoder implements Runnable {
String LOG = "CODEC Decoder ";
private static AudioDecoder decoder;
private static final int MAX_BUFFER_SIZE = 2048;
private byte[] decodedData = new byte[1024];// data of decoded
private boolean isDecoding = false;
private List<AudioData> dataList = null;
public static AudioDecoder getInstance() {
if (decoder == null) {
decoder = new AudioDecoder();
}
return decoder;
}
private AudioDecoder() {
this.dataList = Collections
.synchronizedList(new LinkedList<AudioData>());
}
/*
* add Data to be decoded
*
* @ data:the data recieved from server
*
* @ size:data size
*/
public void addData(byte[] data, int size) {
AudioData adata = new AudioData();
adata.setSize(size);
byte[] tempData = new byte[size];
System.arraycopy(data, 0, tempData, 0, size);
adata.setRealData(tempData);
dataList.add(adata);
System.out.println(LOG + "add data once");
}
/*
* start decode AMR data
*/
public void startDecoding() {
System.out.println(LOG + "start decoder");
if (isDecoding) {
return;
}
new Thread(this).start();
}
public void run() {
// start player first
AudioPlayer player = AudioPlayer.getInstance();
player.startPlaying();
//
this.isDecoding = true;
// init ILBC parameter:30 ,20, 15
AudioCodec.audio_codec_init(30);
Log.d(LOG, LOG + "initialized decoder");
int decodeSize = 0;
while (isDecoding) {
while (dataList.size() > 0) {
AudioData encodedData = dataList.remove(0);
decodedData = new byte[MAX_BUFFER_SIZE];
byte[] data = encodedData.getRealData();
//
decodeSize = AudioCodec.audio_decode(data, 0,
encodedData.getSize(), decodedData, 0);
if (decodeSize > 0) {
// add decoded audio to player
player.addData(decodedData, decodeSize);
// clear data
decodedData = new byte[decodedData.length];
}
}
}
System.out.println(LOG + "stop decoder");
// stop playback audio
player.stopPlaying();
}
public void stopDecoding() {
this.isDecoding = false;
}
}

3.AudioPlayer代码：

播放器的工作流程其实和解码器一模一样，都是启动一个线程，然后不断从自己的 dataList中提取数据。

不过要注意，播放器的一些参数配置非常的关键；

播放声音时，使用了Android自带的 AudioTrack 这个类，它有这个方法：

public int write(byte[] audioData,int offsetInBytes, int sizeInBytes)可以直接播放；

所有播放器的代码如下：

package xmu.swordbearer.audio.receiver;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import xmu.swordbearer.audio.data.AudioData;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioRecord;
import android.media.AudioTrack;
import android.util.Log;
public class AudioPlayer implements Runnable {
String LOG = "AudioPlayer ";
private static AudioPlayer player;
private List<AudioData> dataList = null;
private AudioData playData;
private boolean isPlaying = false;
private AudioTrack audioTrack;
private static final int sampleRate = 8000;
// 注意：参数配置
private static final int channelConfig = AudioFormat.CHANNEL_IN_MONO;
private static final int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
private AudioPlayer() {
dataList = Collections.synchronizedList(new LinkedList<AudioData>());
}
public static AudioPlayer getInstance() {
if (player == null) {
player = new AudioPlayer();
}
return player;
}
public void addData(byte[] rawData, int size) {
AudioData decodedData = new AudioData();
decodedData.setSize(size);
byte[] tempData = new byte[size];
System.arraycopy(rawData, 0, tempData, 0, size);
decodedData.setRealData(tempData);
dataList.add(decodedData);
}
/*
* init Player parameters
*/
private boolean initAudioTrack() {
int bufferSize = AudioRecord.getMinBufferSize(sampleRate,
channelConfig, audioFormat);
if (bufferSize < 0) {
Log.e(LOG, LOG + "initialize error!");
return false;
}
audioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
channelConfig, audioFormat, bufferSize, AudioTrack.MODE_STREAM);
// set volume:设置播放音量
audioTrack.setStereoVolume(1.0f, 1.0f);
audioTrack.play();
return true;
}
private void playFromList() {
while (dataList.size() > 0 && isPlaying) {
playData = dataList.remove(0);
audioTrack.write(playData.getRealData(), 0, playData.getSize());
}
}
public void startPlaying() {
if (isPlaying) {
return;
}
new Thread(this).start();
}
public void run() {
this.isPlaying = true;
if (!initAudioTrack()) {
Log.e(LOG, LOG + "initialized player error!");
return;
}
while (isPlaying) {
if (dataList.size() > 0) {
playFromList();
} else {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
}
}
}
if (this.audioTrack != null) {
if (this.audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) {
this.audioTrack.stop();
this.audioTrack.release();
}
}
Log.d(LOG, LOG + "end playing");
}
public void stopPlaying() {
this.isPlaying = false;
}
}

4.简易服务端：

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

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class AudioServer implements Runnable {
DatagramSocket socket;
DatagramPacket packet;// 从客户端接收到的UDP包
DatagramPacket sendPkt;// 转发给另一个客户端的UDP包
byte[] pktBuffer = new byte[1024];
int bufferSize = 1024;
boolean isRunning = false;
int myport = 5656;
// ///////////
String clientIpStr = "192.168.1.104";
InetAddress clientIp;
int clientPort = 5757;
public AudioServer() {
try {
clientIp = InetAddress.getByName(clientIpStr);
} catch (UnknownHostException e1) {
e1.printStackTrace();
}
try {
socket = new DatagramSocket(myport);
packet = new DatagramPacket(pktBuffer, bufferSize);
} catch (SocketException e) {
e.printStackTrace();
}
System.out.println("服务器初始化完成");
}
public void startServer() {
this.isRunning = true;
new Thread(this).start();
}
public void run() {
try {
while (isRunning) {
socket.receive(packet);
sendPkt = new DatagramPacket(packet.getData(),
packet.getLength(), packet.getAddress(), clientPort);
socket.send(sendPkt);
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
}
}
// main
public static void main(String[] args) {
new AudioServer().startServer();
}
}

5.结语：

Android使用 ILBC 进行语音通话的大致过程就讲述完了，此系列只是做一个ILBC 使用原理的介绍，距离真正的语音

通话还有很多工作要做，缺点还是很多的：

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

也要做很多工作；

2. 实时性：本程序在局域网中使用时，实时性还是较高的，但是再广域网中，效果可能会有所下降，除此之外，本

程序还缺少时间戳的处理，如果网络状况不理想，或者数据延迟，就会导致语音播放前后混乱；

3. 服务器很弱：真正的流媒体服务器，需要很强的功能，来对数据进行处理，我是为了方便，就写了一个简单的，

最近打算移植live555，用来做专门的流媒体服务器，用RTP协议对数据进行封装，这样效果应该会好很多。

现在，整个工程的代码都完成了，全部源代码可以在这里下载： http://download.youkuaiyun.com/detail/ranxiedao/4923759

BY:http://blog.youkuaiyun.com/ranxiedao

转载于:https://www.cnblogs.com/songtzu/archive/2013/02/04/2891982.html