Android音频子系统，Audiopolicyservice音频策略的制定（五）

傷城~ 2022-06-05 02:41 648阅读 0赞

Audiopolicyservice的路由实现：

Audiopolicyservice作为音频策略的制定者，功能的实现跟audiotrack（使用者）有较大关联，所以在紧接着audiotrack看下路由的过程。

路由，就要有发送方，接收方，这个场景中发送发就是Audiotrack，接收方就是audioflinger（策略的执行者），audiopolicyservice是这两者的桥梁，它内部拥有当前系统中所有音频设备的信息，实现音频策略的算法也不是固定的，是可以由厂商定制的。

依据前面的分析，在audiotrack中的set方法，调用audiosystem:: getOutputForAttr()来分析策略的实现：

status_t AudioTrack::createTrack_l()@AudioTrack.cpp{
    	status = AudioSystem::getOutputForAttr(attr, &output,…);
    }
    status_t AudioSystem::getOutputForAttr(…)@ AudioSystem.cpp {
    	const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    	return aps->getOutputForAttr(…);
    }

AudioSystem是一个中介，实现是由AudioPolicyService完成的。

audio_io_handle_t AudioPolicyService::getOutput(…)@ AudioPolicyInterfaceImplLegacy.cpp{
    	return mpAudioPolicy->get_output(…);
    }

前面分析过，mpAudioPolicy就是lap （类型：legacy\_audio\_policy）中的policy（类型：audio\_policy），根据其相应函数指针的实现：

static int create_legacy_ap(…)@ audio_policy_hal.cpp {
    	struct legacy_audio_policy *lap;
    	lap->policy.get_output = ap_get_output;
    }
    static audio_io_handle_t ap_get_output(…) @ audio_policy_hal.cpp {
    	lap->apm->getOutput(…);
    }

Getoutput最终的实现在AudioPolicyManagerBase中。

audio_io_handle_t AudioPolicyManagerBase::getOutput(AudioSystem::stream_type stream,
                                        uint32_t samplingRate,
                                        audio_format_t format,
                                        audio_channel_mask_t channelMask,
                                        AudioSystem::output_flags flags,
                      const audio_offload_info_t *offloadInfo)@ AudioPolicyManagerBase.cpp {
    //step1,获取stream音频类型对应的strategy。
    	routing_strategy strategy = getStrategy((AudioSystem::stream_type)stream);
    	audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
    //step2,依据策略，判断哪些output符合传入的stream类型。
    	SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);
    //step3，选择最优的output
    	output = selectOutput(outputs, flags);
    }

Step1，每种stream类型，都有对应的路由策略routing\_strategy，stream type和routing\_strategy的对应关系：

![Center][]

不同的stream类型，可能使用同一个strategy，可以通过重载getStrategy定制策略。

找到stream类型对应的strategy后，getDeviceForStrategy将为strategy匹配最佳的音频设备。

audio_devices_t AudioPolicyManagerBase::getDeviceForStrategy(routing_strategy strategy,
                                                                 bool fromCache){
    	switch (strategy) {
    		case STRATEGY_MEDIA: {
    			uint32_t device2 = AUDIO_DEVICE_NONE;
    	        if ((device2 == AUDIO_DEVICE_NONE) &&
                    mHasA2dp && (mForceUse[AudioSystem::FOR_MEDIA] != AudioSystem::FORCE_NO_BT_A2DP) &&
                    (getA2dpOutput() != 0) && !mA2dpSuspended) {
                device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
                if (device2 == AUDIO_DEVICE_NONE) {
                    device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
                }
                if (device2 == AUDIO_DEVICE_NONE) {
                    device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
                }
            	}
    	
    	        if (device2 == AUDIO_DEVICE_NONE) {
                device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
            }
            if (device2 == AUDIO_DEVICE_NONE) {
                device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_WIRED_HEADSET;
            }
            if (device2 == AUDIO_DEVICE_NONE) {
                device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_ACCESSORY;
            }
            if (device2 == AUDIO_DEVICE_NONE) {
                device2 = mAvailableOutputDevices & AUDIO_DEVICE_OUT_USB_DEVICE;
            }
    }
            device |= device2;
    //如果匹配到合适的device，跳出switch。
            if (device) break;
    //否则，使用默认的device
            device = mDefaultOutputDevice;
    }
    }

以上匹配的过程是有优先级的，从上到下依次匹配，优先级递减，前一个优先级匹配成功，device2就不为AUDIO\_DEVICE\_NONE了，所以下面的就不在判断了。

Step2，上一步找到匹配的device，这一步为device选择合适的output通道。

SortedVector<audio_io_handle_t> AudioPolicyManagerBase::getOutputsForDevice(audio_devices_t device,
        DefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor *> openOutputs){
    	SortedVector<audio_io_handle_t> outputs;
        for (size_t i = 0; i < openOutputs.size(); i++) {
            if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) {
                outputs.add(openOutputs.keyAt(i));
            }
        }
    }

所有支持device设备的output都被添加到outputs中，这里的output就是前面AudioFlinger::openOutput的执行结果，因为每个output通常支持若干种音频设备，不同的output支持的音频设备类型没有限制，所以可能存在多个支持同一个device的output。

Step3，既然符合要求的output不止一个，就选择一个最合适的。

audio_io_handle_t AudioPolicyManagerBase::selectOutput(
    const SortedVector<audio_io_handle_t>& outputs,
    AudioSystem::output_flags flags)){
    //如果没有output存在，只能返回0，如果只有一个output，就直接返回这个output。
        if (outputs.size() == 0) {
            return 0;
        }
        if (outputs.size() == 1) {
            return outputs[0];
    }
    //选择最优的一个，针对每个output循环计算：outputDesc->mProfile->mFlags & flags的最大值，也就是计算其中的1的个数。
        for (size_t i = 0; i < outputs.size(); i++) {
            AudioOutputDescriptor *outputDesc = mOutputs.valueFor(outputs[i]);
            if (!outputDesc->isDuplicated()) {
                int commonFlags = (int)AudioSystem::popCount(outputDesc->mProfile->mFlags & flags);
                if (commonFlags > maxCommonFlags) {
                    outputFlags = outputs[i];
                    maxCommonFlags = commonFlags;
                }
                if (outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) {
                    outputPrimary = outputs[i];
                }
            }
        }
    }

这个择优判断的规则，也是有优先级的：

首先：请求策略的flags，值最大的那个output，也就是：outputDesc->mProfile->mFlags和flags的值最大的那个。

然后：the primaryoutput

最后：the first output in thelist。

[Center]: /images/20220605/12152aa61a204a49853787c3043cd52c.png