AndroidQ | AudioFlinger_android audioflinger

Audioflinger负责管理android的所有音频设备，包括输入和输出。在Android Audio系统中，AudioFlinger起到承上启下的作用，上接AudioTrack/AudioRecord/AudioSystem等，下接AudioHal。AudioFlnger对上层会提供各种功能接口调用，对下层会对每个AudioHal设备开启一个独立线程，负责音频数据的管理。本文就依据AudioFlinger的作用来分析部分主要代码。

1 AudioFlinger Service注册

frameworks\av\media\audioserver\main_audioserver.cpp

int main(int argc __unused, char **argv)
{
...
        sp<IServiceManager> sm = defaultServiceManager();
        ALOGI("ServiceManager: %p", sm.get());
        AudioFlinger::instantiate();------------------audioflinger service注册
...
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
...
}
1
2
3
4
5
6
7
8
9
10
11

audioflinger注册后，client就可以使用IAudioFlinger声明的功能了，最主要的功能无非就是获取track和record对象，播放或者录取音频数据，设置或查询音量及其他参数等。

2 创建Playback和Record线程

2.1 Playback线程

对于每个播放设备，audioflinger都会创建一个线程来循环向hal层传输音频数据，具体的接口是openOutput，然后调用openOutput_l来具体创建线程

sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
                                                        audio_io_handle_t *output,
                                                        audio_config_t *config,
                                                        audio_devices_t deviceType,
                                                        const String8& address,
                                                        audio_output_flags_t flags)
{
    AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);--------1.查询hal音频设备
...
    if (*output == AUDIO_IO_HANDLE_NONE) {
        *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);-------------------2.分配唯一id
...
    AudioStreamOut *outputStream = NULL;
    status_t status = outHwDev->openOutputStream(
            &outputStream,----------------------------------------------------3.获取stream
            *output,
            deviceType,
            flags,
            config,
            address.string());

    mHardwareStatus = AUDIO_HW_IDLE;

    if (status == NO_ERROR) {
...
        } else {
            sp<PlaybackThread> thread;
...
            } else {---------------------------------------------------------4.创建playback线程
                thread = new MixerThread(this, outputStream, *output, mSystemReady);
                ALOGV("openOutput_l() created mixer output: ID %d thread %p",
                      *output, thread.get());
            }
            mPlaybackThreads.add(*output, thread);---------------------------5.加入vector
...
        }
    }
...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

线程第一次被引用的时候线程就会运行起来，如下

void AudioFlinger::PlaybackThread::onFirstRef()
{
    run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
}
1
2
3
4

对于不同类型的设备会创建不同的线程，flag和thread的对应关系如下表：

来看下两个典型的类继承关系：

线程运行起来会一直在threadLoop中保持循环，playback最主要的功能就是在这里了，这个函数比较长，我们分段来看下

• 首先是这个大循环，退出循环后，会做一些资源处理

bool AudioFlinger::PlaybackThread::threadLoop()
{
...
    // loopCount is used for statistics and diagnostics.
    for (int64_t loopCount = 0; !exitPending(); ++loopCount)
    {
    	...
    }

    threadLoop_exit();

    if (!mStandby) {
        threadLoop_standby();
        mStandby = true;
    }

    releaseWakeLock();
...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 循环第一步，判断线程是否有活动的track，是否要进standby等

        { // scope for mLock
            Mutex::Autolock _l(mLock);------作用域内的lock
...
            if (mSignalPending) {
                // A signal was raised while we were unlocked
                mSignalPending = false;
            } else if (waitingAsyncCallback_l()) {
                if (exitPending()) {
                    break;
                }
                bool released = false;
                if (!keepWakeLock()) {
                    releaseWakeLock_l();
                    released = true;
                }
...
                continue;
            }
            if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
                                   isSuspended()) {
                // put audio hardware into standby after short delay
                if (shouldStandby_l()) {

                    threadLoop_standby();
...
                }

                if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
                    // we're about to wait, flush the binder command buffer
                    IPCThreadState::self()->flushCommands();

                    clearOutputTracks();

                    if (exitPending()) {
                        break;
                    }
...
                    mWaitWorkCV.wait(mLock);
                    ALOGV("%s waking up", myName.string());
                    acquireWakeLock_l();
...
                    continue;
                }
            }
            // mMixerStatusIgnoringFastTracks is also updated internally
            mMixerStatus = prepareTracks_l(&tracksToRemove);
...
            activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
        } // mLock scope ends
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

• 循环第二步，处理track buffer的长度

        if (mBytesRemaining == 0) {
            mCurrentWriteLength = 0;
            if (mMixerStatus == MIXER_TRACKS_READY) {
                // threadLoop_mix() sets mCurrentWriteLength
                threadLoop_mix();
            } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
                        && (mMixerStatus != MIXER_DRAIN_ALL)) {
				...
                if (mSleepTimeUs == 0) {
                    mCurrentWriteLength = mSinkBufferSize;
					...
                }
            }
            // Either threadLoop_mix() or threadLoop_sleepTime() should have set
            // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
            // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
            // or mSinkBuffer (if there are no effects).
            //
            // This is done pre-effects computation; if effects change to
            // support higher precision, this needs to move.
            //
            // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
            // TODO use mSleepTimeUs == 0 as an additional condition.
            if (mMixerBufferValid) {
				...
                memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
                        mNormalFrameCount * (mChannelCount + mHapticChannelCount));
				...
            }

            mBytesRemaining = mCurrentWriteLength;
			...

            // only process effects if we're going to write
            if (mSleepTimeUs == 0 && mType != OFFLOAD) {
				...
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

• 循环第三步，开始向hal层传输数据

        if (!waitingAsyncCallback()) {
            // mSleepTimeUs == 0 means we must write to audio hardware
            if (mSleepTimeUs == 0) {
				...
                if (mBytesRemaining) {
					...
                    ret = threadLoop_write();----------------------传输数据
                    const int64_t lastIoEndNs = systemTime();
                    if (ret < 0) {
                        mBytesRemaining = 0;
                    } else if (ret > 0) {
                        mBytesWritten += ret;
                        mBytesRemaining -= ret;
						...
                    }
                } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
                        (mMixerStatus == MIXER_DRAIN_ALL)) {
                    threadLoop_drain();
                }
                if (mType == MIXER && !mStandby) {
				...
                }

            } else {
                ATRACE_BEGIN("sleep");
				...
                ATRACE_END();
            }
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

• 循环第四步，处理不活动的track等

        threadLoop_removeTracks(tracksToRemove);
        tracksToRemove.clear();
        clearOutputTracks();
        effectChains.clear();
1
2
3
4

2.2 Record线程

创建Record线程的函数为openInput->openInput_l

sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
                                                         audio_io_handle_t *input,
                                                         audio_config_t *config,
                                                         audio_devices_t devices,
                                                         const String8& address,
                                                         audio_source_t source,
                                                         audio_input_flags_t flags,
                                                         audio_devices_t outputDevice,
                                                         const String8& outputDeviceAddress)
{
    AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);---------------查询hal设备
...
    if (*input == AUDIO_IO_HANDLE_NONE) {
        *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);------------------------分配唯一id
    } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
...
    }
...
    status_t status = inHwHal->openInputStream(---------------------------------打开stream
            *input, devices, &halconfig, flags, address.string(), source,
            outputDevice, outputDeviceAddress, &inStream);
...
    if (status == NO_ERROR && inStream != 0) {
        AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
        if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
...
        } else {
...
            sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);-----创建线程
            mRecordThreads.add(*input, thread);------------------------------加入vector
...
        }
    }
...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Record线程根据设备的类型可以分两种

3 创建AudioTrack和AudioRecord

3.1 AudioTrack

用户要播放音频，就要创建一个AudioTrack对象，具体调用步骤为AudioTrack@AudioTrack->set@AudioTrack->createTrack_l@AudioTrack

status_t AudioTrack::createTrack_l()
{
...
    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
...
    sp<IAudioTrack> track = audioFlinger->createTrack(input,
                                                      output,
                                                      &status);
...
	mAudioTrack = track;
...
}
1
2
3
4
5
6
7
8
9
10
11
12

IAudioTrack封装了binder通信的接口，这里通过binder通信机制来获取binder句柄，最终来和service端通信，这个还是要看一下

    virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
                                        CreateTrackOutput& output,
                                        status_t *status)
    {
        Parcel data, reply;
        sp<IAudioTrack> track;
        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());

        if (status == nullptr) {
            return track;
        }

        input.writeToParcel(&data);

        status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply);----通过AudioFlinger获取数据
        if (lStatus != NO_ERROR) {
            ALOGE("createTrack transaction error %d", lStatus);
            *status = DEAD_OBJECT;
            return track;
        }
        *status = reply.readInt32();
        if (*status != NO_ERROR) {
            ALOGE("createTrack returned error %d", *status);
            return track;
        }
        track = interface_cast<IAudioTrack>(reply.readStrongBinder());-------数据转化为binder句柄
        if (track == 0) {
            ALOGE("createTrack returned an NULL IAudioTrack with status OK");
            *status = DEAD_OBJECT;
            return track;
        }
        output.readFromParcel(&reply);
        return track;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

接下来看AudioFlinger那边的实现

sp<IAudioTrack> AudioFlinger::createTrack(const CreateTrackInput& input,
                                          CreateTrackOutput& output,
                                          status_t *status)
{
...
    {
...
        track = thread->createTrack_l(client, streamType, localAttr, &output.sampleRate,
                                      input.config.format, input.config.channel_mask,
                                      &output.frameCount, &output.notificationFrameCount,
                                      input.notificationsPerBuffer, input.speed,
                                      input.sharedBuffer, sessionId, &output.flags,
                                      callingPid, input.clientInfo.clientTid, clientUid,
                                      &lStatus, portId);
...
        }
...
    // return handle to client
    trackHandle = new TrackHandle(track);
...
    return trackHandle;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

然后需要把track对象加入到PlaybackThread的vector中，调用的函数为start，最终会调用到Bn端的start实现，我们来看下Bn端继承的对象

status_t AudioFlinger::TrackHandle::start() {
    return mTrack->start();--------mTrack的类型为PlaybackThread::Track
}
1
2
3

status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
                                                    audio_session_t triggerSession __unused)
{
	...
    if (thread != 0) {
		...
        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
		...
        status = playbackThread->addTrack_l(this);
		...
    } else {
        status = BAD_VALUE;
    }
...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

调用PlaybackThread来加入到线程中

status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
{
    status_t status = ALREADY_EXISTS;

    if (mActiveTracks.indexOf(track) < 0) {
		...
        mActiveTracks.add(track);---------正式加入到线程中
		...
    }
	...
}
1
2
3
4
5
6
7
8
9
10
11

3.2 AudioRecord

对于AudioRecord就直接来看start的实现

status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
                                           AudioSystem::sync_event_t event,
                                           audio_session_t triggerSession)
{
	...

    {
		...
        mActiveTracks.add(recordTrack);
		...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12