转载请注明出处：http://blog.csdn.net/zhaokaiqiang1992
前两篇介绍了声波验证/通信的原理和声音播放的实现，这一篇将介绍最重要。也是最难懂的东西，就是SinVoice是怎样对这些数字进行编码传输的。
由于源码中增加了大量的难以区分的回调函数。为了阅读方便，我进行了部分的重命名和代码的整理，大家不要感到诧异。
首先给出项目的结构：
这篇文章重点介绍是Encoder类、SinGenerator类，Buffer类。
在前面的文章中，我们了解到SinVoiceplayer是我们直接接触和使用的类，使用SinVoicePlayer.play(text)方法就能够非常easy的播放出我们想要传输的数字的相应音频信号。然后进行解析就可以。
在SinVoicePlayer中，是通过调用PcmPlayer的start()方法，进行播放操作的，而在pcmPlayer中，则是又调用AudioTrace来实现终于的音频播放功能。
通过对AudioTrace的一层层封装，终于实现了SinVoicePlayer的简单调用。
既然AudioTrace是终于进行音频播放的类。那么，要进行播放的数据从哪里来的呢？
答案就是，数据来自Encoder类、SinGenerator类和Buffer类。
以下是Encoder的代码，代码经过了整理
/*
* Copyright (C) 2013 gujicheng
*
* Licensed under the GPL License Version 2.0;
* you may not use this file except in compliance with the License.
*
* If you have any question, please contact me.
*
*************************************************************************
** Author information **
*************************************************************************
** Email: gujicheng197@126.com **
** QQ : 29600731 **
** Weibo: http://weibo.com/gujicheng197 **
*************************************************************************
*/
package com.libra.sinvoice;
import java.util.List;
import com.libra.sinvoice.Buffer.BufferData;
/**
*
* @ClassName: com.libra.sinvoice.Encoder
* @Description: 编码器
* @author zhaokaiqiang
* @date 2014-11-16 下午1:32:17
*
*/
public class Encoder implements SinGenerator.SinGeneratorCallback {
private final static String TAG = "Encoder";
private final static int STATE_ENCODING = 1;
private final static int STATE_STOPED = 2;
// index 0, 1, 2, 3, 4, 5, 6
// circleCount 31, 28, 25, 22, 19, 15, 10
private final static int[] CODE_FREQUENCY = { 1422, 1575, 1764, 2004, 2321,
2940, 4410 };
private int mState;
private SinGenerator mSinGenerator;
private EncoderCallback encoderCallback;
public static interface EncoderCallback {
void freeEncodeBuffer(BufferData buffer);
BufferData getEncodeBuffer();
}
public Encoder(EncoderCallback callback, int sampleRate, int bits,
int bufferSize) {
encoderCallback = callback;
mState = STATE_STOPED;
mSinGenerator = new SinGenerator(this, sampleRate, bits, bufferSize);
}
public final static int getMaxCodeCount() {
return CODE_FREQUENCY.length;
}
public final boolean isStoped() {
return (STATE_STOPED == mState);
}
// content of input from 0 to (CODE_FREQUENCY.length-1)
public void encode(List<Integer> codes, int duration) {
if (STATE_STOPED == mState) {
mState = STATE_ENCODING;
mSinGenerator.start();
for (int index : codes) {
if (STATE_ENCODING == mState) {
if (index >= 0 && index < CODE_FREQUENCY.length) {
// 使用正弦发生器编码
mSinGenerator.gen(CODE_FREQUENCY[index], duration);
} else {
LogHelper.d(TAG, "code index error");
}
} else {
LogHelper.d(TAG, "encode force stop");
break;
}
}
mSinGenerator.stop();
}
}
public void stop() {
if (STATE_ENCODING == mState) {
mState = STATE_STOPED;
mSinGenerator.stop();
}
}
@Override
public BufferData getGenBuffer() {
if (null != encoderCallback) {
return encoderCallback.getEncodeBuffer();
}
return null;
}
@Override
public void freeGenBuffer(BufferData buffer) {
if (null != encoderCallback) {
encoderCallback.freeEncodeBuffer(buffer);
}
}
}
关于这个类，主要是以下几点：
1.这个类实现了SinGenerator.SinGeneratorCallback接口，这个接口事实上是SinGenerator类里面的。这个接口主要完毕的数据的获取与释放，在以下的代码中我将会说明
2.数组CODE_FREQUENCY中存放的数字分别代表从0到6相应的频率，不同的数据会依据不同的频率进行编码，circleCount 31, 28, 25, 22, 19, 15, 10 是指在编码的过程中，相应频率的正弦波在一个周期内的取样数量。每个周期的取样数量x周期总数＝总取样数。
还记得之前的DEFAULT_GEN_DURATION＝100吗，这个变量指的就是每个数字相应的音频持续的时间，100代表100毫秒，也就是0.1秒。
我们说过，默认的採样率使用的是44.1KHZ，这是1s内採样44100次。假设须要播放100毫秒，那么就仅仅须要採样44100/10=4410次，由于
private final static int[] CODE_FREQUENCY = { 1422, 1575, 1764, 2004, 2321,2940, 4410 };
假如我们想给数字0编码。那么我们知道0相应的振动频率就是1422HZ。这个也是一秒钟的。假设是100ms呢？就是142.2HZ，我们使用，142.2x31=4408.2,接近4410次，所以说，我们依据想要生成的音频的频率。就能知道每个周期内须要採样多少次，就能算出採样的间隔。
由于Encoder也仅仅是一个包装类，真正实现编码的是SinGenerator,在这个累里面，我们就能够看到非常多的加密细节。
以下是SinGenerator的代码实现
/*
* Copyright (C) 2013 gujicheng
*
* Licensed under the GPL License Version 2.0;
* you may not use this file except in compliance with the License.
*
* If you have any question, please contact me.
*
*************************************************************************
** Author information **
*************************************************************************
** Email: gujicheng197@126.com **
** QQ : 29600731 **
** Weibo: http://weibo.com/gujicheng197 **
*************************************************************************
*/
package com.libra.sinvoice;
import com.libra.sinvoice.Buffer.BufferData;
/**
*
* @ClassName: com.libra.sinvoice.SinGenerator
* @Description: 正弦波发生器
* @author zhaokaiqiang
* @date 2014-11-15 下午2:51:34
*
*/
public class SinGenerator {
private static final String TAG = "SinGenerator";
private static final int STATE_START = 1;
private static final int STATE_STOP = 2;
// 2^8时的峰值
public static final int BITS_8 = 128;
// 默觉得2^16时的峰值
public static final int BITS_16 = 32768;
// 採样率
public static final int SAMPLE_RATE_8 = 8000;
public static final int SAMPLE_RATE_11 = 11250;
public static final int SAMPLE_RATE_16 = 16000;
public static final int UNIT_ACCURACY_1 = 4;
public static final int UNIT_ACCURACY_2 = 8;
private int mState;
private int mSampleRate;
private int mBits;
private static final int DEFAULT_BITS = BITS_8;
private static final int DEFAULT_SAMPLE_RATE = SAMPLE_RATE_8;
private static final int DEFAULT_BUFFER_SIZE = 1024;
private int mFilledSize;
private int mBufferSize;
private SinGeneratorCallback sinGeneratorCallback;
public static interface SinGeneratorCallback {
BufferData getGenBuffer();
void freeGenBuffer(BufferData buffer);
}
public SinGenerator(SinGeneratorCallback callback) {
this(callback, DEFAULT_SAMPLE_RATE, DEFAULT_BITS, DEFAULT_BUFFER_SIZE);
}
public SinGenerator(SinGeneratorCallback callback, int sampleRate,
int bits, int bufferSize) {
sinGeneratorCallback = callback;
mBufferSize = bufferSize;
mSampleRate = sampleRate;
mBits = bits;
mFilledSize = 0;
mState = STATE_STOP;
}
public void stop() {
if (STATE_START == mState) {
mState = STATE_STOP;
}
}
public void start() {
if (STATE_STOP == mState) {
mState = STATE_START;
}
}
/**
* 对数字进行编码
*
* @param genRate
* @param duration
*/
public void gen(int genRate, int duration) {
if (STATE_START == mState) {
// 定值16384
int n = mBits / 2;
int totalCount = (duration * mSampleRate) / 1000;
double per = (genRate / (double) mSampleRate) * 2 * Math.PI;
double d = 0;
LogHelper.d(TAG, "per:" + per + "___genRate:" + genRate);
if (null != sinGeneratorCallback) {
mFilledSize = 0;
// 获取要编码的数据
BufferData bufferData = sinGeneratorCallback.getGenBuffer();
if (null != bufferData) {
for (int i = 0; i < totalCount; ++i) {
if (STATE_START == mState) {
// 算出不同点的正弦值
int out = (int) (Math.sin(d) * n) + 128;
// 假设填充数量超过了缓冲区的大小，就重置mFilledSize，释放bufferData
if (mFilledSize >= mBufferSize - 1) {
// free buffer
bufferData.setFilledSize(mFilledSize);
sinGeneratorCallback.freeGenBuffer(bufferData);
mFilledSize = 0;
bufferData = sinGeneratorCallback
.getGenBuffer();
if (null == bufferData) {
LogHelper.d(TAG, "get null buffer");
break;
}
}
// 转码为byte类型并保存。& 0xff是为了防止负数转换出现异常
bufferData.byteData[mFilledSize++] = (byte) (out & 0xff);
if (BITS_16 == mBits) {
bufferData.byteData[mFilledSize++] = (byte) ((out >> 8) & 0xff);
}
d += per;
} else {
LogHelper.d(TAG, "sin gen force stop");
break;
}
}
} else {
LogHelper.d(TAG, "get null buffer");
}
if (null != bufferData) {
bufferData.setFilledSize(mFilledSize);
sinGeneratorCallback.freeGenBuffer(bufferData);
}
mFilledSize = 0;
}
}
}
}
最基本的方法就是gen(),我们对这种方法进行具体的解析。
1int n = mBits / 2; 在这里定义的n。在后面的代码中參与了运算，n是指我们要创建的正弦函数的峰值，就是最高点的值，mBits的值是2^16/2=32768，在这里将峰值除以二，应该是为了识别率考虑，由于在将n直接赋值为mBits的时候，发出的声音较为尖锐，识别率减少非常多，所以，这里选择了mBits/2最为峰值。
2.int totalCount = (duration * mSampleRate) / 1000;这个是在计算要循环的次数，由于duration＝100，所以採样的总次数是4410，循环运行4410次
3.double per = (genRate / (double) mSampleRate) * 2 * Math.PI;这个per參数是用来记录在循环的过程中，每次往前步进的距离，这个是和频率相关的。
我们以发出数字5为例。从Encoder类中。我们知道5相应的频率是2940HZ，假设我们要声音播放100ms，那么就须要震动294次。也就是294个正弦周期。
而这294次。依据44.1KHZ的频率。也就是100ms採样4410次的频率。就能够算出在每个周期里面，须要採样4410/294=15,所以一个周期内採样数量是15次。而一个正弦周期的长度是2PI。所以，使用2PI/15＝0.4186。这个值就是这里的per值。
4.int out = (int) (Math.sin(d) * n) + 128; 在计算出per之后。在循环中使用变量d对每次的per进行了累加，然后使用前面的计算公式，就能够计算出在採样点处相应的函数值，在完毕以下的操作之后，就实现了数字的编码
// 转码为byte类型并保存。& 0xff是为了防止负数转换出现异常
bufferData.byteData[mFilledSize++] = (byte) (out & 0xff);
if (BITS_16 == mBits) {
bufferData.byteData[mFilledSize++] = (byte) ((out >> 8) & 0xff);
}
我们看到，在保存编码的时候，使用了Buffre类，这个类是对字节数据进行存储的类。用来保存编码完毕之后的字节数据。以下我们简单看下这个类的代码
/*
* Copyright (C) 2013 gujicheng
*
* Licensed under the GPL License Version 2.0;
* you may not use this file except in compliance with the License.
*
* If you have any question, please contact me.
*
*************************************************************************
** Author information **
*************************************************************************
** Email: gujicheng197@126.com **
** QQ : 29600731 **
** Weibo: http://weibo.com/gujicheng197 **
*************************************************************************
*/
package com.libra.sinvoice;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
*
* @ClassName: com.libra.sinvoice.Buffer
* @Description: 缓冲器
* @author zhaokaiqiang
* @date 2014-11-15 下午1:35:46
*
*/
public class Buffer {
private final static String TAG = "Buffer";
// 生产者队列
private BlockingQueue<BufferData> mProducerQueue;
// 消费者队列
private BlockingQueue<BufferData> mConsumeQueue;
// 缓冲区数量
private int mBufferCount;
// 缓冲区体积
private int mBufferSize;
public Buffer() {
this(Common.DEFAULT_BUFFER_COUNT, Common.DEFAULT_BUFFER_SIZE);
}
public Buffer(int bufferCount, int bufferSize) {
mBufferSize = bufferSize;
mBufferCount = bufferCount;
mProducerQueue = new LinkedBlockingQueue<BufferData>(mBufferCount);
// we want to put the end buffer, so need to add 1
mConsumeQueue = new LinkedBlockingQueue<BufferData>(mBufferCount + 1);
// 初始化生产者队列
for (int i = 0; i < mBufferCount; ++i) {
try {
mProducerQueue.put(new BufferData(mBufferSize));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void reset() {
// 将生产者的空头结点剔除
int size = mProducerQueue.size();
for (int i = 0; i < size; ++i) {
BufferData data = mProducerQueue.peek();
if (null == data || null == data.byteData) {
mProducerQueue.poll();
}
}
// 将消费者中的非空数据增加到生产者其中
size = mConsumeQueue.size();
for (int i = 0; i < size; ++i) {
BufferData data = mConsumeQueue.poll();
if (null != data && null != data.byteData) {
mProducerQueue.add(data);
}
}
LogHelper.d(TAG, "reset ProducerQueue Size:" + mProducerQueue.size()
+ " ConsumeQueue Size:" + mConsumeQueue.size());
}
final public int getEmptyCount() {
return mProducerQueue.size();
}
final public int getFullCount() {
return mConsumeQueue.size();
}
// 获取生产者的头结点，堵塞式
public BufferData getEmpty() {
return getImpl(mProducerQueue);
}
// 增加到生产者中
public boolean putEmpty(BufferData data) {
return putImpl(data, mProducerQueue);
}
// 获取消费者的头结点
public BufferData getFull() {
return getImpl(mConsumeQueue);
}
// 增加到消费者中
public boolean putFull(BufferData data) {
return putImpl(data, mConsumeQueue);
}
// 获取队列的头结点
private BufferData getImpl(BlockingQueue<BufferData> queue) {
if (null != queue) {
try {
return queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}
// 将数据增加到队列中
private boolean putImpl(BufferData data, BlockingQueue<BufferData> queue) {
if (null != queue && null != data) {
try {
queue.put(data);
return true;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return false;
}
// when mData is null, means it is end of input
public static class BufferData {
// 数据容器
public byte byteData[];
// 填充体积
private int mFilledSize;
// 缓冲最大体积
private int mMaxBufferSize;
// 静态空缓冲区
private static BufferData sEmptyBuffer = new BufferData(0);
public BufferData(int maxBufferSize) {
mMaxBufferSize = maxBufferSize;
mFilledSize = 0;
if (maxBufferSize > 0) {
byteData = new byte[mMaxBufferSize];
} else {
byteData = null;
}
}
/**
* 获取空的缓冲区
*
* @return
*/
public static BufferData getEmptyBuffer() {
return sEmptyBuffer;
}
// 重置填充数量
final public void reset() {
mFilledSize = 0;
}
final public int getMaxBufferSize() {
return mMaxBufferSize;
}
// 设置填充数量
final public void setFilledSize(int size) {
mFilledSize = size;
}
final public int getFilledSize() {
return mFilledSize;
}
}
}
Buffer使用两个队列实现了生产者消费者模型，从而保证编译好一个。播放一个，在SinVoicePlayer类里面开了两个线程，分别对两个队列里面的数据进行管理。
这个项目的Demo下载地址https://github.com/ZhaoKaiQiang/SinVoiceDemo
