Android Audio 架构自学笔记（三） audio Flinger 基本概述
通过前两次对android audio整体架构的解析，我们已经基本了解andriod audio框架的基本组成以及android audio hal对上层所提供的基本接口。
由android audio架构中了解，android audio framework中的audioFlinger是andriod audio hal的直接使用者，那么接下来我们就看一下android audioFlinger是如何使用Android audio hal来实现audio基本功能的.
android audioFlinger 服务代码结构大致如下（图中只表现出来一部分）；
通过图中文件名称再结合audio hal功能基本解析的结果，我们就可以大概了解其文件内容；
（1）AudioFlinger为audio Flinger服务的入口，其中应该能够包括audioFlinger对外提供的服务；
（2）AudioHwDevice为audio hal的上层抽象，通过名称我们可以猜测这个文件内容中操作大概与audio hal 的操作相对应；
（3）AudioStreamOut为audio hal outputStream的上层抽象。这里面的内容应该就是与audio hal stream_out的操作相对应。
（4）其他，暂时还没什么头绪。
按照以前的分析方法，我们仍然先去调查audioFlinger对外提供了哪些能力。然后再又上到下的调查方法查看这些能力是怎样与底层hal相结合来进行实现的。
audioFlinger文件声明的主要方法如下：
virtual sp<IAudioTrack> createTrack（参数先略）
virtual sp<IAudioRecord> openRecord(
audio_io_handle_t input,
uint32_t sampleRate,
audio_format_t format,
audio_channel_mask_t channelMask,
const String16& opPackageName,
size_t *pFrameCount,
audio_input_flags_t *flags,
pid_t pid,
pid_t tid,
int clientUid,
audio_session_t *sessionId,
size_t *notificationFrames,
sp<IMemory>& cblk,
sp<IMemory>& buffers,
status_t *status /*non-NULL*/,
audio_port_handle_t portId);
virtual status_t openOutput(audio_module_handle_t module,
audio_io_handle_t *output,
audio_config_t *config,
audio_devices_t *devices,
const String8& address,
uint32_t *latencyMs,
audio_output_flags_t flags);
virtual status_t openInput(audio_module_handle_t module,
audio_io_handle_t *input,
audio_config_t *config,
audio_devices_t *device,
const String8& address,
audio_source_t source,
audio_input_flags_t flags);
virtual audio_module_handle_t loadHwModule(const char *name);
.......
我们先将这些函数摘出来的主要原因是这些函数刚好与我们在hal 层分析的上层操作基本时序相对应，即先加载动态库（loadHwModule），然后根据参数使用方法创建输入输出流（openOutput、openInput），然后再通过流来进行数据操作。
我们先梳理整体时序，然后在了解整体时序的基础之上再对内部细节进行详细了解，否则很容易只关注了细节而忽略了对软件整体设计的理解。
1、virtual audio_module_handle_t loadHwModule(const char *name);通过名称来加载hal
在源码中，我们可以清楚看到loadHwModule对输入参数name合法性检查以及某个系统检查之后就直接调用loadHwModule_l来进行具体功能实现了；
audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
{
for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
ALOGW("loadHwModule() module %s already loaded", name);
return mAudioHwDevs.keyAt(i);
}
}
sp<DeviceHalInterface> dev;
int rc = mDevicesFactoryHal->openDevice(name, &dev);
if (rc) {
ALOGE("loadHwModule() error %d loading module %s", rc, name);
return AUDIO_MODULE_HANDLE_NONE;
}
mHardwareStatus = AUDIO_HW_INIT;
rc = dev->initCheck();
mHardwareStatus = AUDIO_HW_IDLE;
if (rc) {
ALOGE("loadHwModule() init check error %d for module %s", rc, name);
return AUDIO_MODULE_HANDLE_NONE;
}
// Check and cache this HAL's level of support for master mute and master
// volume. If this is the first HAL opened, and it supports the get
// methods, use the initial values provided by the HAL as the current
// master mute and volume settings.
AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
{ // scope for auto-lock pattern
AutoMutex lock(mHardwareLock);
if (0 == mAudioHwDevs.size()) {
mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
float mv;
if (OK == dev->getMasterVolume(&mv)) {
mMasterVolume = mv;
}
mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
bool mm;
if (OK == dev->getMasterMute(&mm)) {
mMasterMute = mm;
}
}
mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
if (OK == dev->setMasterVolume(mMasterVolume)) {
flags = static_cast<AudioHwDevice::Flags>(flags |
AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
}
mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
if (OK == dev->setMasterMute(mMasterMute)) {
flags = static_cast<AudioHwDevice::Flags>(flags |
AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
}
mHardwareStatus = AUDIO_HW_IDLE;
}
audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));
ALOGI("loadHwModule() Loaded %s audio interface, handle %d", name, handle);
return handle;
}
我们对这个函数的基本流程进行梳理：
（1）首先判断输入的参数name是否在某个集合中存在，如果存在则直接返回hanle
（2）如果不存则使用halfactory对象通过名称打开（加载）相应的资源，并返回底层资源对象(dev)
（3）然后通过底层对象dev,先检查资源初始化状态。如果初始化状态符合操作条件则进行下一步操作，否则直接返回错误状态
（4）设置底层设备的音量、mute等属性
（5）生成唯一handle标识，创建上层AudioHwDevice对象与底层资源进行对应。然后将AudioHwDevice对象假如到mAudioHwDevs集合中，并返回对象唯一handle标识
通过上述流程梳理，我们可以了解到如下内容
（1）AudioHwDevice为底层hal的上层抽象，一个AudioHwDevice就对应着一个hal.
（2）我们可以通过AudioHwDevice获取底层资源dev,来对底层资源操作
（3）dev与handle进行绑定。我们可以通过handle在mAudioHwDevs集合中获取AudioHwDevice，然后再获得dev.或者通过name直接获得handle，然后再获得AudioHwDevice进而获得dev
2、virtual status_t openOutputaudio_module_handle_t module...)
在源码中，我们可以清楚看到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 devices,
const String8& address,
audio_output_flags_t flags)
{
AudioHwDevice *outHwDev = findSuitableHwDev_l(module, devices);
if (outHwDev == NULL) {
return 0;
}
if (*output == AUDIO_IO_HANDLE_NONE) {
*output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);
} else {
// Audio Policy does not currently request a specific output handle.
// If this is ever needed, see openInput_l() for example code.
ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);
return 0;
}
mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
// FOR TESTING ONLY:
// This if statement allows overriding the audio policy settings
// and forcing a specific format or channel mask to the HAL/Sink device for testing.
if (!(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
// Check only for Normal Mixing mode
if (kEnableExtendedPrecision) {
// Specify format (uncomment one below to choose)
//config->format = AUDIO_FORMAT_PCM_FLOAT;
//config->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
//config->format = AUDIO_FORMAT_PCM_32_BIT;
//config->format = AUDIO_FORMAT_PCM_8_24_BIT;
// ALOGV("openOutput_l() upgrading format to %#08x", config->format);
}
if (kEnableExtendedChannels) {
// Specify channel mask (uncomment one below to choose)
//config->channel_mask = audio_channel_out_mask_from_count(4); // for USB 4ch
//config->channel_mask = audio_channel_mask_from_representation_and_bits(
// AUDIO_CHANNEL_REPRESENTATION_INDEX, (1 << 4) - 1); // another 4ch example
}
}
AudioStreamOut *outputStream = NULL;
status_t status = outHwDev->openOutputStream(
&outputStream,
*output,
devices,
flags,
config,
address.string());
mHardwareStatus = AUDIO_HW_IDLE;
if (status == NO_ERROR) {
if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
sp<MmapPlaybackThread> thread =
new MmapPlaybackThread(this, *output, outHwDev, outputStream,
devices, AUDIO_DEVICE_NONE, mSystemReady);
mMmapThreads.add(*output, thread);
ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
*output, thread.get());
return thread;
} else {
sp<PlaybackThread> thread;
if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
thread = new OffloadThread(this, outputStream, *output, devices, mSystemReady);
ALOGV("openOutput_l() created offload output: ID %d thread %p",
*output, thread.get());
} else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
|| !isValidPcmSinkFormat(config->format)
|| !isValidPcmSinkChannelMask(config->channel_mask)) {
thread = new DirectOutputThread(this, outputStream, *output, devices, mSystemReady);
ALOGV("openOutput_l() created direct output: ID %d thread %p",
*output, thread.get());
} else {
thread = new MixerThread(this, outputStream, *output, devices, mSystemReady);
ALOGV("openOutput_l() created mixer output: ID %d thread %p",
*output, thread.get());
}
mPlaybackThreads.add(*output, thread);
return thread;
}
}
return 0;
}
我们对这个函数的基本流程进行梳理：
（1）首先根据输入的module以及devices找到底层所使用的hal资源
（2）生成唯一标识的output ID
（3）通过底层资源创建AudioStreamOut 输出数据流
（4）创建一个线程与输出数据流以及outputID进行绑定
（5）将创建的线程进行保存
通过上述流程梳理，我们可以了解到如下内容
（1）openOutput实际就是底层资源根据设备以及设备配置创建输出数据流
（2）每一个数据数据流都与一个线程进行绑定，并以outputID作为唯一标识
那么根据以上内容，我们就可以了解了在audioFlinger对底层audio hal的基本操作模式。
也由此可以推断出上层对数据流的相关操作大概时序为下：
1、先通过openoutput创建数据流
2、通过某种方式获得数据流的唯一标识outputID
3、通过outputID找到数据流对应的线程
4、然后将要写入到输出流的音频数据与线程建立联系，最终将数据写入到hal 层进而写到实际物理设备之中
我们就先将audioFlinger梳理到这里，这次的主要目的就是了解audioflinger与底层hal层的交互的基本步骤，下一步就沿着这个基本步骤，去调查stream对应的线程是如何对stream进行操作的.
