音频通信源码分析

一、手机到单片机的源码分析（Android手机）

由于手机的音频输出信号幅度较弱，且为模拟信号，为将此信号转换为幅值0~5V的数字信号，故使用比较器进行转化。音频信号由放大器的反向脚输入，比较电压从正向脚输入。但音频信号小于比较电压是输出0v，反之输出5v。比较器将音频信号与电压值比较输出成相应高低电平后送至单片机。

第一部分AudioTrack分析

 

1、  Audio系统

1）、AudioManager：管理Audio系统

2）、AudioTrack：播放声音

3）、AudioRecord：录音

其中AudioManager的理解需要考虑整个系统上的声音策略问题，例如来电话铃声，短信铃声等。

/**

     * 发送使能

     * @param outBaudrate 输出波特率

     * @param outDataSize 输出数据大小上限

     * @param outPolart 输出极性

     */

    publicvoid enToSend(int outBaudrate,byte outDataSize)//o

    {

       this.outSize=outDataSize;

       this.outBaudrate=outBaudrate;

       this.audiotrack=new AudioTrack(AudioManager.STREAM_MUSIC,

              this.samplerate,//44100,

              AudioFormat.CHANNEL_CONFIGURATION_MONO,

              AudioFormat.ENCODING_PCM_16BIT,

              AudioTrack.getMinBufferSize(this.samplerate, AudioFormat.CHANNEL_CONFIGURATION_MONO,AudioFormat.ENCODING_PCM_16BIT),//44100,

              AudioTrack.MODE_STREAM

              );

}

 

1、  AudioTrack.MODE_STREAM的意思

AudioTrack中有MODE_STATIC和MODE_STREAM两种分类。STREAM的意思是由用户在应用程序通过write方式把数据一次一次的写到audiotrack中。这个和我们在socket中发送数据一样，应用层从某个地方获取数据，例如通过编解码得到PCM数据，然后write到audiotrack。

这种方式的坏处就是总是在JAVA层和Native层交互，效率损失较大。

而STATIC的意思是一开始创建的时候，就把音频数据放到一个固定的buffer，然后直接传给audiotrack，后续就不用一次次得write了。AudioTrack会自己播放这个buffer中的数据。

这种方法对于铃声等内存占用较小，延时要求较高的声音来说很适用。

2、  streamType

这个在构造AudioTrack的第一个参数中使用。这个参数和Android中的AudioManager有关系，涉及到手机上的音频管理策略。

Android将系统的声音分为以下几类常见的（未写全）：

l         STREAM_ALARM：警告声

l         STREAM_MUSCI：音乐声，例如music等

l         STREAM_RING：铃声

l         STREAM_SYSTEM：系统声音

l         STREAM_VOCIE_CALL：电话声音

 

3、分析之getMinBufferSize

AudioTrack.getMinBufferSize(this.samplerate,AudioFormat.CHANNEL_CONFIGURATION_MONO, AudioFormat.ENCODING_PCM_16BIT)

 

static public intgetMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) {

        int channelCount = 0;

        switch(channelConfig) {

        case AudioFormat.CHANNEL_OUT_MONO:

        caseAudioFormat.CHANNEL_CONFIGURATION_MONO:

            channelCount = 1;

            break;

        case AudioFormat.CHANNEL_OUT_STEREO:

        caseAudioFormat.CHANNEL_CONFIGURATION_STEREO:

            channelCount = 2;--->看到了吧，外面名字搞得这么酷，其实就是指声道数

            break;

        default:

            loge("getMinBufferSize():Invalid channel configuration.");

            return AudioTrack.ERROR_BAD_VALUE;

        }

    //目前只支持PCM8和PCM16精度的音频   

        if ((audioFormat !=AudioFormat.ENCODING_PCM_16BIT)

            && (audioFormat !=AudioFormat.ENCODING_PCM_8BIT)) {

            loge("getMinBufferSize():Invalid audio format.");

            return AudioTrack.ERROR_BAD_VALUE;

        }

      //ft，对采样频率也有要求，太低或太高都不行，人耳分辨率在20HZ到40KHZ之间

        if ( (sampleRateInHz < 4000) ||(sampleRateInHz > 48000) ) {

            loge("getMinBufferSize():" + sampleRateInHz +"Hz is not a supported sample rate.");

            return AudioTrack.ERROR_BAD_VALUE;

        }

       //调用native函数，够烦的，什么事情都搞到JNI层去。

        int size =native_get_min_buff_size(sampleRateInHz, channelCount, audioFormat);

        if ((size == -1) || (size == 0)) {

            loge("getMinBufferSize():error querying hardware");

            return AudioTrack.ERROR;

        }

        else {

            return size;

        }

native_get_min_buff_size--->在framework/base/core/jni/android_media_track.cpp中实现。（不了解JNI的一定要学习下，否则只能在JAVA层搞，太狭隘了。）最终对应到函数

static jintandroid_media_AudioTrack_get_min_buff_size(JNIEnv *env,  jobject thiz,

jintsampleRateInHertz, jint nbChannels, jint audioFormat)

{//注意我们传入的参数是：

//sampleRateInHertz= 8000

//nbChannels= 2；

//audioFormat= AudioFormat.ENCODING_PCM_16BIT

    int afSamplingRate;

    int afFrameCount;

    uint32_t afLatency;

//下面涉及到AudioSystem，这里先不解释了，

//反正知道从AudioSystem那查询了一些信息

    if(AudioSystem::getOutputSamplingRate(&afSamplingRate) != NO_ERROR) {

        return -1;

    }

    if(AudioSystem::getOutputFrameCount(&afFrameCount) != NO_ERROR) {

        return -1;

    }

   

    if(AudioSystem::getOutputLatency(&afLatency) != NO_ERROR) {

        return -1;

    }

//音频中最常见的是frame这个单位，什么意思？经过多方查找，最后还是在ALSA的wiki中

//找到解释了。一个frame就是1个采样点的字节数*声道。为啥搞个frame出来？因为对于多//声道的话，用1个采样点的字节数表示不全，因为播放的时候肯定是多个声道的数据都要播出来//才行。所以为了方便，就说1秒钟有多少个frame，这样就能抛开声道数，把意思表示全了。

    // Ensure that buffer depth covers at leastaudio hardware latency

    uint32_t minBufCount = afLatency / ((1000 *afFrameCount)/afSamplingRate);

    if (minBufCount < 2) minBufCount = 2;

uint32_tminFrameCount =

 (afFrameCount*sampleRateInHertz*minBufCount)/afSamplingRate;

//下面根据最小的framecount计算最小的buffersize   

int minBuffSize =minFrameCount

            * (audioFormat ==javaAudioTrackFields.PCM16 ? 2 : 1)

            * nbChannels;

    return minBuffSize;

}

getMinBufSize函数完了后，我们得到一个满足最小要求的缓冲区大小。这样用户分配缓冲区就有了依据。下面就需要创建AudioTrack对象了

 

3、  分析之newAudioTrack

this.audiotrack=newAudioTrack(AudioManager.STREAM_MUSIC,

              this.samplerate,//44100,

        AudioFormat.CHANNEL_CONFIGURATION_MONO,

           AudioFormat.ENCODING_PCM_16BIT,

        AudioTrack.getMinBufferSize(this.samplerate, AudioFormat.CHANNEL_CONFIGURATION_MONO,AudioFormat.ENCODING_PCM_16BIT),//44100,

              AudioTrack.MODE_STREAM

);

 

其实现代码在AudioTrack.java中。

publicAudioTrack(int streamType, int sampleRateInHz, int channelConfig, intaudioFormat,

            int bufferSizeInBytes, int mode)

    throws IllegalArgumentException {

        mState = STATE_UNINITIALIZED;

       

        // 获得主线程的Looper，这个在MediaScanner分析中已经讲过了

        if ((mInitializationLooper =Looper.myLooper()) == null) {

            mInitializationLooper =Looper.getMainLooper();

        }

   

        //检查参数是否合法之类的，可以不管它

        audioParamCheck(streamType,sampleRateInHz, channelConfig, audioFormat, mode);

   //我是用getMinBufsize得到的大小，总不会出错吧？

        audioBuffSizeCheck(bufferSizeInBytes);

 

        // 调用native层的native_setup，把自己的WeakReference传进去了

     //不了解JAVAWeakReference的可以上网自己查一下，很简单的

        int initResult = native_setup(newWeakReference<AudioTrack>(this),

                mStreamType, 这个值是AudioManager.STREAM_MUSIC

 mSampleRate, 这个值是8000

mChannels, 这个值是2

mAudioFormat,这个值是AudioFormat.ENCODING_PCM_16BIT

                mNativeBufferSizeInBytes, //这个是刚才getMinBufSize得到的

mDataLoadMode);DataLoadMode是MODE_STREAM

         ....

}

上面函数调用最终进入了JNI层android_media_AudioTrack.cpp下面的函数

static int

android_media_AudioTrack_native_setup(JNIEnv*env, jobject thiz, jobject weak_this,

        jint streamType, jintsampleRateInHertz, jint channels,

        jint audioFormat, jint buffSizeInBytes,jint memoryMode)

{

    int afSampleRate;

    int afFrameCount;

   下面又要调用一堆东西，烦不烦呐？具体干什么用的，以后分析到AudioSystem再说。

   AudioSystem::getOutputFrameCount(&afFrameCount, streamType)；

   AudioSystem::getOutputSamplingRate(&afSampleRate,streamType)；

 

   AudioSystem::isOutputChannel(channels)；

    popCount是统计一个整数中有多少位为1的算法

int nbChannels =AudioSystem::popCount(channels);

   

    if (streamType ==javaAudioTrackFields.STREAM_MUSIC) {

        atStreamType = AudioSystem::MUSIC;

    }

   int bytesPerSample = audioFormat ==javaAudioTrackFields.PCM16 ? 2 : 1;

    int format = audioFormat ==javaAudioTrackFields.PCM16 ?

            AudioSystem::PCM_16_BIT :AudioSystem::PCM_8_BIT;

    int frameCount = buffSizeInBytes /(nbChannels * bytesPerSample);

//上面是根据Buffer大小和一个Frame大小来计算帧数的。

// AudioTrackJniStorage，就是一个保存一些数据的地方，这

//里边有一些有用的知识，下面再详细解释

    AudioTrackJniStorage* lpJniStorage = newAudioTrackJniStorage();

     jclass clazz =env->GetObjectClass(thiz);

      lpJniStorage->mCallbackData.audioTrack_class= (jclass)env->NewGlobalRef(clazz);

    lpJniStorage->mCallbackData.audioTrack_ref =env->NewGlobalRef(weak_this);

     lpJniStorage->mStreamType =atStreamType;

//创建真正的AudioTrack对象

    AudioTrack* lpTrack = new AudioTrack();

       if (memoryMode ==javaAudioTrackFields.MODE_STREAM) {

  //如果是STREAM流方式的话，把刚才那些参数设进去

       lpTrack->set(

            atStreamType,// stream type

            sampleRateInHertz,

            format,// word length, PCM

            channels,

            frameCount,

            0,// flags

            audioCallback,

&(lpJniStorage->mCallbackData),//callback,callback data (user)

            0,// notificationFrames == 0 sincenot using EVENT_MORE_DATA to feed the AudioTrack

            0,// 共享内存，STREAM模式需要用户一次次写，所以就不用共享内存了

            true);// thread can call Java

           

    } else if (memoryMode ==javaAudioTrackFields.MODE_STATIC) {

         //如果是static模式，需要用户一次性把数据写进去，然后

       //再由audioTrack自己去把数据读出来，所以需要一个共享内存

//这里的共享内存是指C++AudioTrack和AudioFlinger之间共享的内容

 //因为真正播放的工作是由AudioFlinger来完成的。

         lpJniStorage->allocSharedMem(buffSizeInBytes);

          lpTrack->set(

            atStreamType,// stream type

            sampleRateInHertz,

            format,// word length, PCM

            channels,

            frameCount,

            0,// flags

            audioCallback,

&(lpJniStorage->mCallbackData),//callback,callback data (user));

            0,// notificationFrames == 0 sincenot using EVENT_MORE_DATA to feed the AudioTrack

            lpJniStorage->mMemBase,// sharedmem

            true);// thread can call Java

    }

 

    if (lpTrack->initCheck() != NO_ERROR) {

        LOGE("Error initializingAudioTrack");

        goto native_init_failure;

    }

//又来这一招，把C++AudioTrack对象指针保存到JAVA对象的一个变量中

//这样，Native层的AudioTrack对象就和JAVA层的AudioTrack对象关联起来了。

    env->SetIntField(thiz,javaAudioTrackFields.nativeTrackInJavaObj, (int)lpTrack);

    env->SetIntField(thiz,javaAudioTrackFields.jniData, (int)lpJniStorage);

  }

 

 

4、  分析之play和write

JAVA层到这一步后就是调用play和write了。JAVA层这两个函数没什么内容，都是直接转到native层干活了。

先看看play函数对应的JNI函数

static void

android_media_AudioTrack_start(JNIEnv*env, jobject thiz)

{

//看见没，从JAVA那个AudioTrack对象获取保存的C++层的AudioTrack对象指针

//从int类型直接转换成指针。要是以后ARM变成64位平台了，看google怎么改！

    AudioTrack *lpTrack = (AudioTrack*)env->GetIntField(

        thiz,javaAudioTrackFields.nativeTrackInJavaObj);

    lpTrack->start(); //这个以后再说

}

下面是write。我们写的是short数组，

static jint

android_media_AudioTrack_native_write_short(JNIEnv*env,  jobject thiz,

                                                 jshortArray javaAudioData,

                                                 jint offsetInShorts,

jintsizeInShorts,

                                                 jint javaAudioFormat) {

    return (android_media_AudioTrack_native_write(env,thiz,

                                                (jbyteArray) javaAudioData,

                                                offsetInShorts*2, sizeInShorts*2,

                                                javaAudioFormat)

            / 2);

}

烦人，又根据Byte还是Short封装了下，最终会调到重要函数writeToTrack去

jintwriteToTrack(AudioTrack* pTrack, jint audioFormat, jbyte* data,

                  jint offsetInBytes, jintsizeInBytes) {

      ssize_t written = 0;

    // regular write() or copy the data to theAudioTrack's shared memory?

if (pTrack->sharedBuffer() == 0) {

//创建的是流的方式，所以没有共享内存在track中

//还记得我们在native_setup中调用的set吗？流模式下AudioTrackJniStorage可没创建

//共享内存

        written = pTrack->write(data +offsetInBytes, sizeInBytes);

    } else {

        if (audioFormat ==javaAudioTrackFields.PCM16) {

            // writing to shared memory, checkfor capacity

            if ((size_t)sizeInBytes >pTrack->sharedBuffer()->size()) {

                sizeInBytes = pTrack->sharedBuffer()->size();

            }

           //看见没？STATIC模式的，就直接把数据拷贝到共享内存里

         //当然，这个共享内存是pTrack的，是我们在set时候把AudioTrackJniStorage的

//共享设进去的

           memcpy(pTrack->sharedBuffer()->pointer(),

data + offsetInBytes, sizeInBytes);

            written = sizeInBytes;

        } else if (audioFormat ==javaAudioTrackFields.PCM8) {

           PCM8格式的要先转换成PCM16

           

    }

    return written;

}

到这里，似乎很简单啊，JAVA层的AudioTrack，无非就是调用write函数，而实际由JNI层的C++AudioTrack write数据。反正JNI这层是再看不出什么有意思的东西了

AudioTrack总结

通过这一次的分析，我自己觉得有以下几个点：

l         AudioTrack的工作原理，尤其是数据的传递这一块，做了比较细致的分析，包括共享内存，跨进程的同步等，也能解释不少疑惑了。

l         看起来，最重要的工作是在AudioFlinger中做的。通过AudioTrack的介绍，我们给后续深入分析AudioFlinger提供了一个切入点

 工作原理和流程嘛，再说一次好了，JAVA层就看最前面那个例子吧，实在没什么说的。

l         AudioTrack被new出来，然后set了一堆信息，同时会通过Binder机制调用另外一端的AudioFlinger，得到IAudioTrack对象，通过它和AudioFlinger交互。

l         调用start函数后，会启动一个线程专门做回调处理，代码里边也会有那种数据拷贝的回调，但是JNI层的回调函数实际并没有往里边写数据，大家只要看write就可以了

l         用户一次次得write，那AudioTrack无非就是把数据memcpy到共享buffer中咯

l         可想而知，AudioFlinger那一定有一个线程在memcpy数据到音频设备中去。我们拭目以待。

bnSend.setOnClickListener(newView.OnClickListener() {

                            public voidonClick(View v) {

                                     Stringstr=etSendText.getText().toString();

                                     if(audiosrlter!=null)

                                     {

                                               audiosrlter.write(str);

                                     }

                                     else

                                     {

                                               //TODO null

                                     }

                            }

                   });