Android 录音数据传输

今天来看看Android中的录音数据是怎么来的。


从AudioRecord开始看吧。


AudioRecord中可以取得录音数据的接口是：AudioRecord::read。
首先调用函数obtainBuffer取得录音数据的地址。
然后用memcpy将录音数据copy出来。


看样子，数据来源是obtainBuffer函数了。


来看看函数AudioRecord::obtainBuffer。
其主要功能就是对传入的audioBuffer进行赋值。
audioBuffer是Buffer* 类型。


看看Buffer类：


    class Buffer
    {
    public:
        enum {
            MUTE    = 0x00000001
        };
        uint32_t    flags;
        int         channelCount;
        int         format;
        size_t      frameCount;
        size_t      size;
        union {
            void*       raw;
            short*      i16;
            int8_t*     i8;
        };
    };

其中保存数据的是下面这块东东：
        union {
            void*       raw;
            short*      i16;
            int8_t*     i8;
        };

函数AudioRecord::obtainBuffer中对这块东东赋值的代码如下：
audioBuffer->raw         = (int8_t*)cblk->buffer(u);


cblk的来历：
    audio_track_cblk_t* cblk = mCblk;

mCblk的赋值在函数AudioRecord::openRecord中被赋值：
    mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());
    mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); // 可见mCblk头部保存的是结构体的信息，后面跟的是数据

函数audio_track_cblk_t::buffer的实现：
void* audio_track_cblk_t::buffer(uint64_t offset) const
{
    return (int8_t *)this->buffers + (offset - userBase) * this->frameSize;
}


可见数据就保存在audio_track_cblk_t结构体中。


是什么地方往结构体audio_track_cblk_t中写的数据呢？


发现函数AudioRecord::obtainBuffer中，在获取buffer地址时，首先会调用函数audio_track_cblk_t::framesReady来判断有多少数据准备好了。


想起来在播放数据的时候，使用audio_track_cblk_t中的数据时，也调用了函数audio_track_cblk_t::framesReady。
而往audio_track_cblk_t中写数据时，调用了函数audio_track_cblk_t::framesAvailable。


录音肯定也是这样的了。
也就是说，找到调用函数audio_track_cblk_t::framesAvailable的地方，也就找到了往audio_track_cblk_t中写数据的地方。


录音相关，调用audio_track_cblk_t::framesAvailable的地方如下：
AudioFlinger::RecordThread::RecordTrack::getNextBuffer函数。


函数AudioFlinger::RecordThread::RecordTrack::getNextBuffer的主要作用是给传入的AudioBufferProvider::Buffer赋值。


AudioBufferProvider::Buffer结构体类型：
    struct Buffer {
        union {
            void*       raw;
            short*      i16;
            int8_t*     i8;
        };
        size_t frameCount;
    };

保存数据的是下面这块东东：
        union {
            void*       raw;
            short*      i16;
            int8_t*     i8;
        };

函数AudioFlinger::RecordThread::RecordTrack::getNextBuffer对这块东东赋值的代码如下：
        buffer->raw = getBuffer(s, framesReq);

函数AudioFlinger::ThreadBase::TrackBase::getBuffer返回了一个int8_t型指针bufferStart。
对bufferStart赋值的代码如下：
int8_t *bufferStart = (int8_t *)mBuffer + (offset-cblk->serverBase)*cblk->frameSize;


mBuffer的赋值在AudioFlinger::ThreadBase::TrackBase::TrackBase的构造函数中：
mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
mCblk 的来历：
mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer()); 或 new(mCblk) audio_track_cblk_t();
这个在研究播放音频流的时候已经看过，这儿就不重复了。


肯定是哪个地方调用了函数AudioFlinger::RecordThread::RecordTrack::getNextBuffer，获取一段buffer，然后将录音数据写入到这个buffer。


搜搜调用函数AudioFlinger::RecordThread::RecordTrack::getNextBuffer的地方，录音相关的调用有以下：
AudioFlinger::RecordThread::threadLoop函数


AudioFlinger::RecordThread::threadLoop函数中，调用函数AudioFlinger::RecordThread::RecordTrack::getNextBuffer获取了buffer。
然后将buffer赋值给了dst：
int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) * mActiveTrack->mCblk->frameSize;


下面要分两种情况来讨论了：
+++++++++++++++++++++++++++++++++++++++不需要resampling的情况-start++++++++++++++++++++++++++++++++++++++++++++++
往dst写数据的有以下两个地方：
                                    while (framesIn--) {
                                        *dst16++ = *src16;
                                        *dst16++ = *src16++;
                                    }
或：
                                    while (framesIn--) {
                                        *dst16++ = (int16_t)(((int32_t)*src16 + (int32_t)*(src16 + 1)) >> 1);
                                        src16 += 2;
                                    }

也就是说数据来源是src了，看看src的由来。
int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize;


对mRsmpInBuffer赋值的地方在函数AudioFlinger::RecordThread::readInputParameters中：
mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount];


这儿只是new了个buffer，寻找数据来源，还要看哪儿往里面写数据了。
往 mRsmpInBuffer中写数据的地方也在AudioFlinger::RecordThread::threadLoop函数中：
                                mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes);
----------------------------------------不需要resampling的情况-end-----------------------------------------------
+++++++++++++++++++++++++++++++++++++++需要resampling的情况-start++++++++++++++++++++++++++++++++++++++++++++++
往dst写数据的地方：
                        while (framesOut--) {
                            *dst++ = (int16_t)(((int32_t)*src + (int32_t)*(src + 1)) >> 1);
                            src += 2;
                        }

也就是说数据来源是src了，看看src的由来。
                        int16_t *src = (int16_t *)mRsmpOutBuffer;

对mRsmpInBuffer赋值的地方在函数AudioFlinger::RecordThread::readInputParameters中：
mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount];


这儿只是new了个buffer，寻找数据来源，还要看哪儿往里面写数据了。
往 mRsmpInBuffer中写数据的地方在AudioFlinger::RecordThread::getNextBuffer函数中：
        mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes);

下面看看对AudioFlinger::RecordThread::getNextBuffer函数的调用：


首先函数AudioFlinger::RecordThread::threadLoop中调用了函数AudioResamplerOrder1::resample。
                    mResampler->resample(mRsmpOutBuffer, framesOut, this);
函数AudioResamplerOrder1::resample调用了函数AudioResamplerOrder1::resampleMono16：
        resampleMono16(out, outFrameCount, provider);
函数AudioResamplerOrder1::resampleMono16中调用了函数AudioFlinger::RecordThread::getNextBuffer：
            provider->getNextBuffer(&mBuffer);

mResampler的赋值在函数AudioFlinger::RecordThread::readInputParameters中：
        mResampler = AudioResampler::create(16, channelCount, mReqSampleRate);

函数AudioResampler::create根据参数，返回不同的resampler：
switch (quality) {
    default:
    case LOW_QUALITY:
        LOGV("Create linear Resampler");
        resampler = new AudioResamplerOrder1(bitDepth, inChannelCount, sampleRate);
        break;
    case MED_QUALITY:
        LOGV("Create cubic Resampler");
        resampler = new AudioResamplerCubic(bitDepth, inChannelCount, sampleRate);
        break;
    case HIGH_QUALITY:
        LOGV("Create sinc Resampler");
        resampler = new AudioResamplerSinc(bitDepth, inChannelCount, sampleRate);
        break;
    }

从上面对函数AudioFlinger::RecordThread::getNextBuffer的调用可知，mRsmpOutBuffer最终作为参数out传给了函数AudioResamplerOrder1::resampleMono16。
最终往mRsmpOutBuffer中写数据的地方是在函数AudioResamplerOrder1::resampleMono16中：


        // handle boundary case
        while (inputIndex == 0) {
            // LOGE("boundary case\n");
            int32_t sample = Interp(mX0L, in[0], phaseFraction);
            out[outputIndex++] += vl * sample;
            out[outputIndex++] += vr * sample;
            Advance(&inputIndex, &phaseFraction, phaseIncrement);
            if (outputIndex == outputSampleCount)
                break;
        }

或：


        while (outputIndex < outputSampleCount && inputIndex < mBuffer.frameCount) {
            int32_t sample = Interp(in[inputIndex-1], in[inputIndex],
                    phaseFraction);
            out[outputIndex++] += vl * sample;
            out[outputIndex++] += vr * sample;
            Advance(&inputIndex, &phaseFraction, phaseIncrement);
        }

in的来历：
        int16_t *in = mBuffer.i16;

mBuffer的赋值：
            provider->getNextBuffer(&mBuffer);

回到了刚次说的对函数AudioFlinger::RecordThread::getNextBuffer的调用。


函数AudioFlinger::RecordThread::getNextBuffer中首先调用函数AudioStreamInALSA::read获取数据指针。
        mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes);

然后将数据地址赋值给传入的AudioBufferProvider::Buffer指针：
    buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount;

下面看看resampling对数据的处理。


            int32_t sample = Interp(in[inputIndex-1], in[inputIndex],
                    phaseFraction);

phaseFraction的来源：
    uint32_t phaseFraction = mPhaseFraction;

phaseFraction作为参数传给了函数Advance：
            Advance(&inputIndex, &phaseFraction, phaseIncrement);

函数Advance中对phaseFraction进行了赋值：
    static inline void Advance(size_t* index, uint32_t* frac, uint32_t inc) {
        *frac += inc;
        *index += (size_t)(*frac >> kNumPhaseBits);
        *frac &= kPhaseMask;
    }

常量的定义：
    // number of bits for phase fraction - 28 bits allows nearly 8x downsampling
    static const int kNumPhaseBits = 28;


    // phase mask for fraction
    static const uint32_t kPhaseMask = (1LU<<kNumPhaseBits)-1;

再看看Interp函数：
    static inline int32_t Interp(int32_t x0, int32_t x1, uint32_t f) {
        return x0 + (((x1 - x0) * (int32_t)(f >> kPreInterpShift)) >> kNumInterpBits);
    }

常量定义：
    // number of bits used in interpolation multiply - 15 bits avoids overflow
    static const int kNumInterpBits = 15;


    // bits to shift the phase fraction down to avoid overflow
    static const int kPreInterpShift = kNumPhaseBits - kNumInterpBits;

再看vl和vr：
    int32_t vl = mVolume[0];
    int32_t vr = mVolume[1];

mVolume在函数AudioResampler::setVolume中被赋值：
void AudioResampler::setVolume(int16_t left, int16_t right) {
    // TODO: Implement anti-zipper filter
    mVolume[0] = left;
    mVolume[1] = right;
}


函数AudioResampler::setVolume在函数AudioFlinger::RecordThread::readInputParameters中被调用：
        mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN);

常量定义：
    static const uint16_t UNITY_GAIN = 0x1000;
----------------------------------------需要resampling的情况-end-----------------------------------------------


可以，无论是否resampling，都是通过调用函数AudioStreamInALSA::read来获取数据。


函数AudioStreamInALSA::read中调用了ALSA Lib中的函数snd_pcm_mmap_readi或函数snd_pcm_readi来取得数据：
        if (mHandle->mmap)
            n = snd_pcm_mmap_readi(mHandle->handle, buffer, frames);
        else
            n = snd_pcm_readi(mHandle->handle, buffer, frames);

http://blog.csdn.net/njuitjf/article/details/7458872