AudioTrack流程分析

vimer-hz

已于 2023-12-23 15:24:45 修改

阅读量1.6k

点赞数

分类专栏： 3.2.1 Android系统经验文章标签： AudioTrack

于 2021-05-30 23:35:13 首次发布

原文链接：https://blog.csdn.net/Innost/article/details/6125779

版权

3.2.1 Android系统经验专栏收录该内容

29 篇文章 9 订阅

订阅专栏

转载自:

Android深入浅出之Audio 第一部分 AudioTrack分析_阿拉神农的博客-CSDN博客

UML顺序图:

AudioTrack.svg

https://download.csdn.net/download/u012906122/19589063

Audio里主要有三个功能：

AudioManager：这个主要是用来管理Audio系统的

AudioTrack：这个主要是用来播放声音的

AudioRecord：这个主要是用来录音的

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

一个简单的API使用流程:

//根据采样率，采样精度，单双声道来得到frame的大小。
int bufsize = AudioTrack.getMinBufferSize(8000,    //每秒8K个点
　　AudioFormat.CHANNEL_CONFIGURATION_STEREO,      //双声道
    AudioFormat.ENCODING_PCM_16BIT);               //一个采样点16比特-2个字节
//创建AudioTrack
AudioTrack trackplayer = new AudioTrack(AudioManager.STREAM_MUSIC, 8000,
　　AudioFormat.CHANNEL_CONFIGURATION_STEREO,
　　AudioFormat.ENCODING_PCM_16BIT,
　　bufsize,
    AudioTrack.MODE_STREAM);
trackplayer.play() ;   //开始
trackplayer.write(bytes_pkg, 0, bytes_pkg.length); //往track中写数据
….
trackplayer.stop();    //停止播放
trackplayer.release(); //释放底层资源

这里需要解释下两个东西：

1 AudioTrack.MODE_STREAM：

AudioTrack中有MODE_STATIC和MODE_STREAM两种分类。STREAM的意思是由用户在应用层通过write方式把数据一次一次得写到audiotrack中。这种方式的坏处就是总是在JAVA层和Native层交互，效率损失较大。

而STATIC的意思是一开始创建的时候，就把音频数据放到一个固定的buffer，然后直接传给audiotrack，后续就不用一次次得write了。AudioTrack会自己播放这个buffer中的数据。这种方法对于铃声等内存占用较小，延时要求较高的声音来说很适用。

2 StreamType

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

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

STREAM_ALARM：警告声

STREAM_MUSCI：音乐声

STREAM_RING：铃声

STREAM_SYSTEM：系统声音

STREAM_VOCIE_CALL：电话声音

根据UML顺序图详细说明：

1 getMinBufferSize

JAVA的AudioTrack类的代码在framework/base/media/java/android/media/AudioTrack.java中

static public int getMinBufferSize(int sampleRateInHz, int channelConfig, int audioFormat) {
    int channelCount = 0;
    switch(channelConfig) {
        case AudioFormat.CHANNEL_OUT_MONO:
        case AudioFormat.CHANNEL_CONFIGURATION_MONO:
            channelCount = 1;
            break;
        case AudioFormat.CHANNEL_OUT_STEREO:
        case AudioFormat.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;
   }
}

2 native_get_min_buff_size

native_get_min_buff_size最终对应到函数android_media_AudioTrack_get_min_buff_size

3 android_media_AudioTrack_get_min_buff_size

在framework/base/core/jni/android_media_track.cpp中实现

static jint android_media_AudioTrack_get_min_buff_size(JNIEnv *env, jobject thiz, jint sampleRateInHertz, jint nbChannels, jint audioFormat) {      int afSamplingRate;
    int afFrameCount;
    uint32_t afLatency;
    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 least audio hardware latency
    uint32_t minBufCount = afLatency / ((1000 * afFrameCount)/afSamplingRate);
    if (minBufCount < 2) minBufCount = 2;
    uint32_t minFrameCount = (afFrameCount*sampleRateInHertz*minBufCount)/afSamplingRate;
    //下面根据最小的framecount计算最小的buffersize   
    int minBuffSize = minFrameCount
            * (audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1)
            * nbChannels;
    return minBuffSize;
}

getMinBufSize函数完了后，我们得到一个满足最小要求的缓冲区大小。下面就需要创建AudioTrack对象了。

4 new AudioTrack

public AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat, 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);
    audioBuffSizeCheck(bufferSizeInBytes);
    //调用native层的native_setup，把自己的WeakReference传进去了
    //不了解JAVA WeakReference的可以上网自己查一下
    int initResult = native_setup(new WeakReference<AudioTrack>(this),
        mStreamType, 这个值是AudioManager.STREAM_MUSIC
        mSampleRate, 这个值是8000
        mChannels, 这个值是2
        mAudioFormat, 这个值是AudioFormat.ENCODING_PCM_16BIT
        mNativeBufferSizeInBytes, //这个是刚才getMinBufSize得到的
        mDataLoadMode);    //DataLoadMode是MODE_STREAM
         ....
}

5 native_setup

6 android_media_AudioTrack_native_setup

static int android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_this,
        jint streamType, jint sampleRateInHertz, jint channels,
        jint audioFormat, jint buffSizeInBytes, jint memoryMode)
{
    int afSampleRate;
    int afFrameCount;
    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 = new AudioTrackJniStorage();
    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 since not 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 since not using EVENT_MORE_DATA to feed the AudioTrack
            lpJniStorage->mMemBase,// shared mem
            true);// thread can call Java
    }
    if (lpTrack->initCheck() != NO_ERROR) {
        LOGE("Error initializing AudioTrack");
        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);
}

7 AudioTrack* lpTrack = new AudioTrack

那么，我们就看看真正干活的的C++AudioTrack吧。

AudioTrack.cpp位于framework/base/libmedia/AudioTrack.cpp

AudioTrack::AudioTrack()
    : mStatus(NO_INIT) //把状态初始化成NO_INIT。Android大量使用了设计模式中的state。
{
}

8 lpTrack->set

status_t AudioTrack::set(
        int streamType,
        uint32_t sampleRate,
        int format,
        int channels,
        int frameCount,
        uint32_t flags,
        callback_t cbf,
        void* user,
        int notificationFrames,
        const sp<IMemory>& sharedBuffer,
        bool threadCanCallJava)
{
    //...前面一堆的判断，等以后讲AudioSystem再说
    audio_io_handle_t output =
    AudioSystem::getOutput((AudioSystem::stream_type)streamType,
            sampleRate, format, channels, (AudioSystem::output_flags)flags);
    status_t status = createTrack(streamType, sampleRate, format, channelCount,
                                  frameCount, flags, sharedBuffer, output);
    //cbf是JNI传入的回调函数audioCallback
    if (cbf != 0) { //看来，怎么着也要创建这个线程了！
        mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
    }
    return NO_ERROR;
}

9 createTrack

status_t AudioTrack::createTrack(
        int streamType,
        uint32_t sampleRate,
        int format,
        int channelCount,
        int frameCount,
        uint32_t flags,
        const sp<IMemory>& sharedBuffer,
        audio_io_handle_t output)
{
    status_t status;
    //和audioFlinger挂上关系了
    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
    //下面这个调用最终会在AudioFlinger中出现。暂时不管它。
    sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),
                                                      streamType,
                                                      sampleRate,
                                                      format,
                                                      channelCount,
                                                      frameCount,
                                                      ((uint16_t)flags) << 16,
                                                      sharedBuffer,
                                                      output,
                                                      &status);
    //从track也就是AudioFlinger那边得到一个IMemory接口
    //这个看来就是最终write写入的地方
    sp<IMemory> cblk = track->getCblk();
    mAudioTrack.clear();
    mAudioTrack = track;
    mCblkMemory.clear();
    mCblkMemory = cblk;
    mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());
    mCblk->out = 1;
    mFrameCount = mCblk->frameCount;
    if (sharedBuffer == 0) {
    //终于看到buffer相关的了。注意我们这里的情况STREAM模式没有传入共享buffer，但是数据确实又需要buffer承载。反正AudioTrack是没有创建buffer，那只能是刚才从AudioFlinger中得到的buffer了。
        mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
    }
    return NO_ERROR;
}

10 audioFlinger->createTrack

AudioTrack得到AudioFlinger中的一个IAudioTrack对象。

AudioTrack创建了一个线程，叫AudioTrackThread。

AudioTrack调用write函数，肯定是把数据写到那块共享缓冲了，然后IAudioTrack在另外一个进程AudioFlinger中（其实AudioFlinger是一个服务，在mediaservice中运行）接收数据，并最终写到音频设备中。

11 new AudioTrackThread

创建了一个线程

AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava)
    : Thread(bCanCallJava), mReceiver(receiver)
{  //mReceiver就是AudioTrack对象
   // bCanCallJava为TRUE
}

12 play

13 android_media_AudioTrack_start

play函数对应的JNI函数android_media_AudioTrack_start

static void android_media_AudioTrack_start(JNIEnv *env, jobject thiz)
{
    //从JAVA那个AudioTrack对象获取保存的C++层的AudioTrack对象指针
    AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(
        thiz, javaAudioTrackFields.nativeTrackInJavaObj);
    lpTrack->start();
}

14 start

start函数调用AudioTrackThread启动一个新的线程，执行mAudioTrackThread的threadLoop

void AudioTrack::start()
{
    //start函数调用AudioTrackThread函数触发产生一个新的线程，执行mAudioTrackThread的threadLoop
    sp<AudioTrackThread> t = mAudioTrackThread;
    t->run("AudioTrackThread", THREAD_PRIORITY_AUDIO_CLIENT);
    //让AudioFlinger中的track也start
    status_t status = mAudioTrack->start();
}

15 threadLoop()

bool AudioTrack::AudioTrackThread::threadLoop()
{
    //调用AudioTrack的processAudioBuffer函数
    return mReceiver.processAudioBuffer(this);
}

16 processAudioBuffer

bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread)
{
    Buffer audioBuffer;
    uint32_t frames;
    size_t writtenSize;
    //...回调1
    mCbf(EVENT_UNDERRUN, mUserData, 0);
    //...回调2 都是传递一些信息到JNI里边
    mCbf(EVENT_BUFFER_END, mUserData, 0);
    // Manage loop end callback
    while (mLoopCount > mCblk->loopCount) {
        mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount);
    }
    //下面好像有写数据的东西
    do {
        audioBuffer.frameCount = frames;
        //获得buffer，
        status_t err = obtainBuffer(&audioBuffer, 1);
        size_t reqSize = audioBuffer.size;
        //把buffer回调到JNI那去，这是单独一个线程，而我们还有上层用户在那不停地write呢，怎么会这样？
        mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
        audioBuffer.size = writtenSize;
        frames -= audioBuffer.frameCount;
        releaseBuffer(&audioBuffer);
    }
    while (frames);
    return true;
}

17 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer)

static void audioCallback(int event, void* user, void *info) {
    if (event == AudioTrack::EVENT_MORE_DATA) {
         //这个函数没往里边写数据
        AudioTrack::Buffer* pBuff = (AudioTrack::Buffer*)info;
        pBuff->size = 0;
     }
}

从代码上看，本来google考虑是异步的回调方式来写数据，实际上没write，这个AudioTrackThread除了通知一下，也没什么实际有意义的操作了。

18 write

19 android_media_AudioTrack_native_write_short

20 writeToTrack

最终会调到重要函数writeToTrack

jint writeToTrack(AudioTrack* pTrack, jint audioFormat, jbyte* data, jint offsetInBytes, jint sizeInBytes) {
    ssize_t written = 0;
    //regular write() or copy the data to the AudioTrack'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, check for 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;
}

21 pTrack->write

就是obtainBuffer，memcpy数据，然后releaseBuffer

ssize_t AudioTrack::write(const void* buffer, size_t userSize)
{
     //就是obtainBuffer，memcpy数据，然后releaseBuffer
     do {
         audioBuffer.frameCount = userSize/frameSize();
         status_t err = obtainBuffer(&audioBuffer, -1);
         size_t toWrite;
         toWrite = audioBuffer.size;
         memcpy(audioBuffer.i8, src, toWrite);
         src += toWrite;
        }
        userSize -= toWrite;
        written += toWrite;
        releaseBuffer(&audioBuffer);
    } while (userSize);
    return written;
}

AudioTrack总结：

1 通过AudioTrack的介绍，我们给后续深入分析AudioFlinger提供了一个切入点。

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

3 调用start函数后，会启动一个线程专门做回调处理，代码里边也会有那种数据拷贝的回调，但是JNI层的回调函数实际并没有往里边write数据。真正的写数据如图18:write。

4 用户一次次地write，AudioTrack把数据memcpy到共享buffer中

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