audio_policy_configuration.xml加载过程

最新推荐文章于 2024-02-02 20:42:56 发布
最新推荐文章于 2024-02-02 20:42:56 发布
阅读量859 收藏 7
点赞数 1
分类专栏： 安卓音频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_26866585/article/details/105469904
版权

介绍

audio_policy_configuration.xml是在Android 7.0中新引入了音频政策配置文件格式 (XML)，用于描述音频拓扑。
以前的 Android 版本使用 audio_policy.conf 来声明您的产品上存在的音频设备）。但是，CONF 是一种简单的专有格式，有较大的局限性，无法描述电视和汽车等行业的复杂拓扑。
所以，在安卓7.0之后弃用了audio_policy.conf，转而使用XML 文件格式定义音频拓扑的支持，该文件格式更易于阅读，可使用各种修改和解析工具，并且足够灵活，可以描述复杂的音频拓扑。在安卓7.0-9.0依然可以通过在项目的mk中修改宏定义(USE_XML_AUDIO_POLICY_CONF)来使用conf文件，而安卓10以后则彻底不再支持conf文件。

正文

以下代码基于Android 7.1

XML文件一览

以下是S5P4418开发板中的audio_policy_configuration.xml文件

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Copyright (C) 2015 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<audioPolicyConfiguration version="1.0" xmlns:xi="http://www.w3.org/2001/XInclude">

    <!-- Global configuration Decalaration -->
    <globalConfiguration speaker_drc_enabled="true"/>

    <!-- Modules section:
        There is one section per audio HW module present on the platform.
        Each module section will contains two mandatory tags for audio HAL “halVersion” and “name”.
        The module names are the same as in current .conf file:
                “primary”, “A2DP”, “remote_submix”, “USB”
        Each module will contain the following sections:
        “devicePorts”: a list of device descriptors for all input and output devices accessible via this
        module.
        This contains both permanently attached devices and removable devices.
        “mixPorts”: listing all output and input streams exposed by the audio HAL
        “routes”: list of possible connections between input and output devices or between stream and
        devices.
            "route": is defined by an attribute:
                -"type": <mux|mix> means all sources are mutual exclusive (mux) or can be mixed (mix)
                -"sink": the sink involved in this route
                -"sources": all the sources than can be connected to the sink via vis route
        “attachedDevices”: permanently attached devices.
        The attachedDevices section is a list of devices names. The names correspond to device names
        defined in <devicePorts> section.
        “defaultOutputDevice”: device to be used by default when no policy rule applies
    -->
    <modules>
        <!-- Primary Audio HAL -->
        <module name="primary" halVersion="3.0">
            <attachedDevices>
                <item>Speaker</item>
                <item>Built-In Mic</item>
            </attachedDevices>
            <defaultOutputDevice>Speaker</defaultOutputDevice>
            <mixPorts>
                <mixPort name="primary output" role="source" flags="AUDIO_OUTPUT_FLAG_PRIMARY">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>
                <mixPort name="hdmi output" role="source">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>
                <mixPort name="primary input" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
                </mixPort>
            </mixPorts>

            <!-- Output devices declaration, i.e. Sink DEVICE PORT -->
            <devicePorts>
                <devicePort tagName="Speaker" type="AUDIO_DEVICE_OUT_SPEAKER" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </devicePort>
                <devicePort tagName="Wired Headphones" type="AUDIO_DEVICE_OUT_WIRED_HEADPHONE" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </devicePort>
                <devicePort tagName="HDMI Out" type="AUDIO_DEVICE_OUT_AUX_DIGITAL" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </devicePort>
                <devicePort tagName="Built-In Mic" type="AUDIO_DEVICE_IN_BUILTIN_MIC" role="source">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_IN_STEREO"/>
                </devicePort>
            </devicePorts>

            <!-- route declaration, i.e. list all available sources for a given sink -->
            <routes>
                <route type="mix" sink="Speaker"
                       sources="primary output"/>
                <route type="mix" sink="Wired Headphones"
                       sources="primary output"/>
                <route type="mix" sink="HDMI Out"
                       sources="hdmi output"/>
                <route type="mix" sink="primary input"
                       sources="Built-In Mic"/>
            </routes>
        </module>
    </modules>

</audioPolicyConfiguration>

可以发现，这个xml文件的根节点为"audioPolicyConfiguration", 根节点下面依次是“globalConfiguration“和”modules“，因为这个开发板比较简陋，所以并没有很多属性。
modules节点中定义了module属性，每一个module都对应一个hal的库，在这里只有一个module，也就说只有一个hal库(primary),在module中有以下节点:

  • attachedDevices:描述了在当前的设备上连接了哪些音频设备，
  • defaultOutputDevice:默认音频设备
  • mixPorts:描述了可以在音频 HAL 播放和输入的流的配置信息
  • devicePorts:描述了什么type的音频流可以传输到什么设备中
  • routes:描述音频路径，什么样的源(sources)连接到什么样的端点(sink)

这个xml加载过程中会重复调用deserializeCollection函数，这里仅仅以mixPorts节点作为例子

重要的结构体

解析modules时相关的结构体

const char *const ModuleTraits::childAttachedDevicesTag = "attachedDevices";
const char *const ModuleTraits::childAttachedDeviceTag = "item";
const char *const ModuleTraits::childDefaultOutputDeviceTag = "defaultOutputDevice";

const char *const ModuleTraits::tag = "module";
const char *const ModuleTraits::collectionTag = "modules";

const char ModuleTraits::Attributes::name[] = "name";
const char ModuleTraits::Attributes::version[] = "halVersion";

struct ModuleTraits
{
    static const char *const tag;
    static const char *const collectionTag;

    static const char *const childAttachedDevicesTag;
    static const char *const childAttachedDeviceTag;
    static const char *const childDefaultOutputDeviceTag;

    struct Attributes
    {
        static const char name[];
        static const char version[];
    };

    typedef HwModule Element;
    typedef sp<Element> PtrElement;
    typedef HwModuleCollection Collection;
    typedef AudioPolicyConfig *PtrSerializingCtx;

    static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
                                PtrSerializingCtx serializingContext);

    // Children are: mixPortTraits, devicePortTraits and routeTraits
    // Need to call deserialize on each child
};

解析mixPorts的结构体

const char *const MixPortTraits::collectionTag = "mixPorts";
const char *const MixPortTraits::tag = "mixPort";

const char MixPortTraits::Attributes::name[] = "name";
const char MixPortTraits::Attributes::role[] = "role";
const char MixPortTraits::Attributes::flags[] = "flags";

struct MixPortTraits
{
    static const char *const tag;
    static const char *const collectionTag;

    struct Attributes
    {
        static const char name[];
        static const char role[];
        static const char flags[];
    };

    typedef IOProfile Element;
    typedef sp<Element> PtrElement;
    typedef IOProfileCollection Collection;
    typedef void *PtrSerializingCtx;

    static status_t deserialize(_xmlDoc *doc, const _xmlNode *root, PtrElement &element,
                                PtrSerializingCtx serializingContext);

    // Children are: GainTraits
};

const char *const AudioProfileTraits::collectionTag = "profiles";
const char *const AudioProfileTraits::tag = "profile";

const char AudioProfileTraits::Attributes::name[] = "name";
const char AudioProfileTraits::Attributes::samplingRates[] = "samplingRates";
const char AudioProfileTraits::Attributes::format[] = "format";
const char AudioProfileTraits::Attributes::channelMasks[] = "channelMasks";

函数解析过程

audio_policy_configuration.xml是在AudioPolicyManager的构造函数中被加载解析的

AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
    :
#ifdef AUDIO_POLICY_TEST
    Thread(false),
#endif //AUDIO_POLICY_TEST
    mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
    mA2dpSuspended(false),
    mAudioPortGeneration(1),
    mBeaconMuteRefCount(0),
    mBeaconPlayingRefCount(0),
    mBeaconMuted(false),
    mTtsOutputAvailable(false),
    mMasterMono(false)
{
    mUidCached = getuid();
    mpClientInterface = clientInterface;

    // TODO: remove when legacy conf file is removed. true on devices that use DRC on the
    // DEVICE_CATEGORY_SPEAKER path to boost soft sounds, used to adjust volume curves accordingly.
    // Note: remove also speaker_drc_enabled from global configuration of XML config file.
    bool speakerDrcEnabled = false;

#ifdef USE_XML_AUDIO_POLICY_CONF
    mVolumeCurves = new VolumeCurvesCollection();
    AudioPolicyConfig config(mHwModules, mAvailableOutputDevices, mAvailableInputDevices,		//新建AudioPolicyConfig对象
                             mDefaultOutputDevice, speakerDrcEnabled,
                             static_cast<VolumeCurvesCollection *>(mVolumeCurves));
    PolicySerializer serializer;																												//新建PolicySerializer对象用于解析xml
    if (serializer.deserialize(AUDIO_POLICY_XML_CONFIG_FILE, config) != NO_ERROR) {	//#define AUDIO_POLICY_XML_CONFIG_FILE "/system/etc/audio_policy_configuration.xml"
    ///省略

在安卓7.0中，xml的文件位置是写死的，但是在后续的安卓版本中会在多个目录下搜寻xml文件。
在解析xml文件之前，先创建了一个AudioPolicyConfig对象config，并传入了几个对象用于类的初始化，这几个对象都是在AudioPolicyManager类中定义的。
接着创建了PolicySerializer对象，解析xml就是用的这个类的deserialize函数，同时传入了xml文件的路径字串和config对象,在PolicySerializer中解析xml文件用的是libxml2库，代码位于external/tinyxml2/

status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig &config)
{
    xmlDocPtr doc;
    doc = xmlParseFile(configFile);		//调用libxml2库读取xml文件，相当于是文件句柄
    if (doc == NULL) {
        ALOGE("%s: Could not parse %s document.", __FUNCTION__, configFile);
        return BAD_VALUE;
    }
    xmlNodePtr cur = xmlDocGetRootElement(doc);         //获取根节点
    if (cur == NULL) {
        ALOGE("%s: Could not parse %s document: empty.", __FUNCTION__, configFile);
        xmlFreeDoc(doc);
        return BAD_VALUE;
    }
    if (xmlXIncludeProcess(doc) < 0) {					//解析xml的包含关系，我的开发板比较简单，没有包含其他xml
         ALOGE("%s: libxml failed to resolve XIncludes on %s document.", __FUNCTION__, configFile);
    }

    if (xmlStrcmp(cur->name, (const xmlChar *) mRootElementName.c_str()))  { //判断根节点名字是不是"audioPolicyConfiguration"
        ALOGE("%s: No %s root element found in xml data %s.", __FUNCTION__, mRootElementName.c_str(),
              (const char *)cur->name);
        xmlFreeDoc(doc);
        return BAD_VALUE;
    }

    string version = getXmlAttribute(cur, versionAttribute);	//获取xml的版本
    if (version.empty()) {
        ALOGE("%s: No version found in root node %s", __FUNCTION__, mRootElementName.c_str());
        return BAD_VALUE;
    }
    if (version != mVersion) {
        ALOGE("%s: Version does not match; expect %s got %s", __FUNCTION__, mVersion.c_str(),
              version.c_str());
        return BAD_VALUE;
    }
    // Lets deserialize children
    // Modules
    ModuleTraits::Collection modules;	//创建HwModuleCollection对象，开始解析modules节点
    deserializeCollection<ModuleTraits>(doc, cur, modules, &config); //解析modules节点
    config.setHwModules(modules);  //将存储了解析数据的modules赋值给AudioPolicyConfig里面的HwModules

    // deserialize volume section
    VolumeTraits::Collection volumes;	//解析音量相关，但是我的这个xml文件里面并没有包含音量的xml
    deserializeCollection<VolumeTraits>(doc, cur, volumes, &config);
    config.setVolumes(volumes);

    // Global Configuration
    GlobalConfigTraits::deserialize(cur, config);

    xmlFreeDoc(doc);
    return android::OK;
}

}; // namespace android

deserializeCollection
这个函数比较重要，在解析各种节点时都会被调用到。
主要作用是根据当前传入的模板类型，找到当前模板类型所对应的节点，并最终调用当前模板类型的deserialize函数来对节点进行解析
在xml中的各种属性都是先包含在一个Attributes节点下，该节点下再存放具体的Attribute节点
所以各种属性的collectionTag就是对应Attributes节点名称，tag对应Attribute节点

template <class Trait>
static status_t deserializeCollection(_xmlDoc *doc, const _xmlNode *cur,
                                      typename Trait::Collection &collection,
                                      typename Trait::PtrSerializingCtx serializingContext)
{
    const xmlNode *root = cur->xmlChildrenNode;	//进入根节点节点下的第一个节点,这个cur只有在传入ModuleTraits类时是根节点
    while (root != NULL) {						//遍历当前所有节点
        if (xmlStrcmp(root->name, (const xmlChar *)Trait::collectionTag) &&	//根据name来判断当前节点是不是要解析的
                xmlStrcmp(root->name, (const xmlChar *)Trait::tag)) {
            root = root->next;
            continue;
        }
        const xmlNode *child = root;
        if (!xmlStrcmp(child->name, (const xmlChar *)Trait::collectionTag)) {
            child = child->xmlChildrenNode;
        }
        while (child != NULL) {
            if (!xmlStrcmp(child->name, (const xmlChar *)Trait::tag)) {
                typename Trait::PtrElement element;		//HwModule
                status_t status = Trait::deserialize(doc, child, element, serializingContext);	//调用HwModuleCollection::deserialize
                if (status != NO_ERROR) {
                    return status;
                }
                if (collection.add(element) < 0) {	//解析成功则把HwModule插入到HwModuleCollection这个容器中
                    ALOGE("%s: could not add element to %s collection", __FUNCTION__,
                          Trait::collectionTag);
                }
            }
            child = child->next;
        }
        if (!xmlStrcmp(root->name, (const xmlChar *)Trait::tag)) {
            return NO_ERROR;
        }
        root = root->next;
    }
    return NO_ERROR;
}

ModuleTraits::deserialize
解析module节点的函数，解析出来的数据会保存在一个HwModule对象中

status_t ModuleTraits::deserialize(xmlDocPtr doc, const xmlNode *root, PtrElement &module,
                                   PtrSerializingCtx ctx)
{
    string name = getXmlAttribute(root, Attributes::name);
    if (name.empty()) {
        ALOGE("%s: No %s found", __FUNCTION__, Attributes::name);
        return BAD_VALUE;
    }
    uint32_t version = AUDIO_DEVICE_API_VERSION_MIN;
    string versionLiteral = getXmlAttribute(root, Attributes::version);
    if (!versionLiteral.empty()) {
        uint32_t major, minor;
        sscanf(versionLiteral.c_str(), "%u.%u", &major, &minor);
        version = HARDWARE_DEVICE_API_VERSION(major, minor);
        ALOGV("%s: mHalVersion = %04x major %u minor %u",  __FUNCTION__,
              version, major, minor);
    }

    ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::name, name.c_str());

    module = new Element(name.c_str(), version);	//根据名字和版本号创建对象	对应第一个module名字为"primary"

    // Deserialize childrens: Audio Mix Port, Audio Device Ports (Source/Sink), Audio Routes
    MixPortTraits::Collection mixPorts;			//解析mixPorts
    deserializeCollection<MixPortTraits>(doc, root, mixPorts, NULL);	//又是这个函数
    module->setProfiles(mixPorts);

    DevicePortTraits::Collection devicePorts;	//解析devicePorts
    deserializeCollection<DevicePortTraits>(doc, root, devicePorts, NULL);
    module->setDeclaredDevices(devicePorts);

    RouteTraits::Collection routes;				//解析routes
    deserializeCollection<RouteTraits>(doc, root, routes, module.get());
    module->setRoutes(routes);

    const xmlNode *children = root->xmlChildrenNode;	//解析AttachedDevices和DefaultOutputDevice
    while (children != NULL) {
        if (!xmlStrcmp(children->name, (const xmlChar *)childAttachedDevicesTag)) {
            ALOGV("%s: %s %s found", __FUNCTION__, tag, childAttachedDevicesTag);
            const xmlNode *child = children->xmlChildrenNode;
            while (child != NULL) {
                if (!xmlStrcmp(child->name, (const xmlChar *)childAttachedDeviceTag)) {
                    xmlChar *attachedDevice = xmlNodeListGetString(doc, child->xmlChildrenNode, 1);
                    if (attachedDevice != NULL) {
                        ALOGV("%s: %s %s=%s", __FUNCTION__, tag, childAttachedDeviceTag,
                              (const char*)attachedDevice);
                        sp<DeviceDescriptor> device =
                                module->getDeclaredDevices().getDeviceFromTagName(String8((const char*)attachedDevice));
                        ctx->addAvailableDevice(device);
                        xmlFree(attachedDevice);
                    }
                }
                child = child->next;
            }
        }
        if (!xmlStrcmp(children->name, (const xmlChar *)childDefaultOutputDeviceTag)) {
            xmlChar *defaultOutputDevice = xmlNodeListGetString(doc, children->xmlChildrenNode, 1);;
            if (defaultOutputDevice != NULL) {
                ALOGV("%s: %s %s=%s", __FUNCTION__, tag, childDefaultOutputDeviceTag,
                      (const char*)defaultOutputDevice);
                sp<DeviceDescriptor> device =
                        module->getDeclaredDevices().getDeviceFromTagName(String8((const char*)defaultOutputDevice));
                if (device != 0 && ctx->getDefaultOutputDevice() == 0) {
                    ctx->setDefaultOutputDevice(device);
                    ALOGV("%s: default is %08x", __FUNCTION__, ctx->getDefaultOutputDevice()->type());
                }
                xmlFree(defaultOutputDevice);
            }
        }
        children = children->next;
    }
    return NO_ERROR;
}

deserializeCollection(doc, root, mixPorts, NULL);传入的mixPorts是一个IOProfile容器，里面会存放解析出来的mixPort
deserializeCollection函数会创建Trait::Element,并调用Trait::deserialize(doc, child, element, serializingContext)函数进一步解析子节点，在解析相关节点成功后将插入参数中传入的容器中

status_t MixPortTraits::deserialize(_xmlDoc *doc, const _xmlNode *child, PtrElement &mixPort,
                                    PtrSerializingCtx /*serializingContext*/)
{
    string name = getXmlAttribute(child, Attributes::name);             //"name"
    if (name.empty()) {
        ALOGE("%s: No %s found", __FUNCTION__, Attributes::name);
        return BAD_VALUE;
    }
    ALOGV("%s: %s %s=%s", __FUNCTION__, tag, Attributes::name, name.c_str());
    string role = getXmlAttribute(child, Attributes::role);             //"role"
    if (role.empty()) {
        ALOGE("%s: No %s found", __FUNCTION__, Attributes::role);
        return BAD_VALUE;
    }
    ALOGV("%s: Role=%s", __FUNCTION__, role.c_str());
    audio_port_role_t portRole = role == "source" ? AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;  //AUDIO_PORT_ROLE_SOURCE = 1, AUDIO_PORT_ROLE_SINK = 2

    mixPort = new Element(String8(name.c_str()), portRole);     //IOProfile

    AudioProfileTraits::Collection profiles;
    deserializeCollection<AudioProfileTraits>(doc, child, profiles, NULL);          //解析profile节点的属性
    if (profiles.isEmpty()) {
        sp <AudioProfile> dynamicProfile = new AudioProfile(gDynamicFormat,
                                                            ChannelsVector(), SampleRateVector());
        dynamicProfile->setDynamicFormat(true);
        dynamicProfile->setDynamicChannels(true);
        dynamicProfile->setDynamicRate(true);
        profiles.add(dynamicProfile);
    }
    mixPort->setAudioProfiles(profiles);

    string flags = getXmlAttribute(child, Attributes::flags);
    if (!flags.empty()) {
        // Source role
        if (portRole == AUDIO_PORT_ROLE_SOURCE) {
            mixPort->setFlags(OutputFlagConverter::maskFromString(flags));
        } else {
            // Sink role
            mixPort->setFlags(InputFlagConverter::maskFromString(flags));
        }
    }
    // Deserialize children
    AudioGainTraits::Collection gains;
    deserializeCollection<AudioGainTraits>(doc, child, gains, NULL);
    mixPort->setGains(gains);

    return NO_ERROR;
}

//解析profile节点
status_t AudioProfileTraits::deserialize(_xmlDoc */*doc*/, const _xmlNode *root, PtrElement &profile,
                                         PtrSerializingCtx /*serializingContext*/)
{
    string samplingRates = getXmlAttribute(root, Attributes::samplingRates);	//samplingRates
    string format = getXmlAttribute(root, Attributes::format);					//format
    string channels = getXmlAttribute(root, Attributes::channelMasks);			//channelMasks

    profile = new Element(formatFromString(format), channelMasksFromString(channels, ","),
                          samplingRatesFromString(samplingRates, ","));

    profile->setDynamicFormat(profile->getFormat() == gDynamicFormat);
    profile->setDynamicChannels(profile->getChannels().isEmpty());
    profile->setDynamicRate(profile->getSampleRates().isEmpty());

    return NO_ERROR;
}

最终解析出来的结构体

只列出mixPorts

modules //class HwModuleCollection:public Vector<sp<HwModule> >
{
    module1 //class HwModule
    {
        mixPorts    //typedef Vector<sp<IOProfile> > IOProfileCollection;  IOProfile容器
        {
            mixPort1   //class IOProfile : public AudioPort
            {
                name = "primary output";
                role = AUDIO_PORT_ROLE_SOURCE
                mProfiles    class AudioProfileVector : public Vector<sp<AudioProfile> > 相当于AudioProfile容器
                {
                    AudioProfile    //class AudioProfile : public virtual RefBase
                    {
                        format = AUDIO_FORMAT_PCM_16_BIT;
                        channelMasks = AUDIO_CHANNEL_OUT_STEREO;
                        samplingRates = 48000;
                    }
                }
            }
            mixPort2   //
            {
                name = "hdmi output"
                role = AUDIO_PORT_ROLE_SOURCE
                mProfiles    //class AudioProfileVector : public Vector<sp<AudioProfile> > 相当于AudioProfile容器
                {
                    AudioProfile    //class AudioProfile : public virtual RefBase
                    {
                        format = AUDIO_FORMAT_PCM_16_BIT;
                        channelMasks = AUDIO_CHANNEL_OUT_STEREO;
                        samplingRates = 48000;
                    }
                }
            }
            mixPort3   //
            {
                name = "primary input"
                role = AUDIO_PORT_ROLE_SOURCE
                mProfiles    //class AudioProfileVector : public Vector<sp<AudioProfile> > 相当于AudioProfile容器
                {
                    AudioProfile    //class AudioProfile : public virtual RefBase
                    {
                        format = AUDIO_FORMAT_PCM_16_BIT;
                        channelMasks = AUDIO_CHANNEL_IN_STEREO;
                        samplingRates = 48000;
                    }
                }
            }
        }
        devicePorts //
        {
            ...;
        }
        routes      //
        {
            ...;
        }
    }
}
期望99
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android进阶-音频配置文件audio_policy_configuration.xml解析全过程
王涛的博客
08-01 1万+
本文基于android7.0分析 一、前言 audio_policy.conf解析 前面我们已经介绍了audio_policy.conf 的解析全过程，但是，.conf 是一种简单的专有格式，有较大的局限性，无法描述电视和汽车等应用的复杂拓扑。Android 7.0 弃用了audio_policy.conf，并增加了对使用 XML 文件格式来定义音频拓扑的支持，这种文件格式更通俗易懂，具有多种编...
Android Audio基础——音频配置xml文件加载（七）
最新发布
小旭的专栏
06-03 472
通过前面的文章，我们知道在 AudioPolicyManager 初始化的时候回调用 loadConfig() 方法去加载 Audio 相关的配置信息，这里我们就来详细看一下。
Android源码分析－－Audio设备文件解析(07)
wangrl的博客
01-25 1715
上篇文章中只是讲到配置文件在哪里，怎么读取文件，但是真正的文件解析还没有开始。这篇就开始分析文件解析，认识这些解析的参数。  接着上篇Audio设备文件加载继续进行分析，知道主要是这个函数起到解析的作用。 static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) { char audioPo
audio_policy_configuration.xml 解析
少侠的专栏
11-15 9117
android的audioserver 进程启动时，会创建AudioPolicyManager, 洋洋洒洒数千行的其构造函数，第一步就是加载配置相关的xml。 #define AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH 128 #define AUDIO_POLICY_XML_CONFIG_FILE_NAME &amp;amp;amp;amp;amp;amp;quot;audio_policy_config...
audio_policy_configuration.xml
12-22
android 音频设备配置文件
audio_policy_configuration.xml文件解析
jackzhouyu的专栏
12-16 9211
audio_policy_configuration.xml文件解析 简介 audio音频数据从一个源走到一个目的都是需要根据配置文件来决定，所以理解configuration配置文件中各个标签项转化为c++实体类的及各成员至关重要，本文先直接给出各标签和对应实体类的结果，后再简单分析其解析过程 audio_policy_configuration.xml文件对应C++实体类 configuration文件(audio_policy_configuration的缩写)为音频audio的设备、流以及路由等配
Android开发之音频配置文件audio_policy_configuration.xml解析全过程
年少生而为人
10-05 3918
本文基于android7.0分析 一、前言 audio_policy.conf解析 前面我们已经介绍了audio_policy.conf 的解析全过程，但是，.conf 是一种简单的专有格式，有较大的局限性，无法描述电视和汽车等应用的复杂拓扑。Android 7.0 弃用...
audio_tuningTool_QUEUE40797675.rar
12-28
音频调音工具(audio_tuningTool)是音频处理领域的一个重要工具，主要用于调整和优化音频文件的音质。在"audio_tuningTool_QUEUE40797675.rar"这个压缩包中，我们可以预见到包含了一系列与音频调音相关的资源和软件。...
audio_realtek_6.0.1.8591_w71064.zip
04-09
标题 "audio_realtek_6.0.1.8591_w71064.zip" 暗示这是一个Realtek音频驱动程序的压缩包，版本号为6.0.1.8591，专为Windows 7 64位系统设计。描述中的内容与标题相同，进一步确认了这是Realtek音频驱动的更新或...
Audio_Tuning_Tool_exe_v2.2016.rar
09-25
《MTK平台音频调校工具Audio_Tuning_Tool_exe_v2.2016详解》 在移动设备领域，音质的优化与调校是提升用户体验的关键环节之一。针对MTK（MediaTek）平台，开发者们推出了Audio_Tuning_Tool_exe_v2.2016这一专业工具...
Realtek_Audio Console_1.2.169.0(station-drivers).zip
05-02
此时，"Realtek_Audio Console_1.2.169.0(station-drivers).zip"这个压缩包就显得尤为重要，它提供了一个方便快捷的方式来恢复和重新安装Realtek音频控制台。 该压缩包内含"Audio Console_Realtek_1.2.169.0_W10x64...
audio_policy_configuration.xml解读与配置
和大伙儿去乘凉
01-20 5342
audio_policy_configuration.xml xml中 的<modules>对应每一个audio hal 的so，module中列出的mixPorts，devicePorts和routes解析之后完整的描述了音频的路由规则， module name。支持“primary”（用于车载使用场景）、“A2DP”、“remote_submix”和“USB”。模块名称和相应音频驱动程序应编译到audio.primary.$(variant).so中。 devicePorts。包...
Android9.0 audio_policy_configuration.xml解析
suwen8100的博客
05-06 3568
frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp 的源码： AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface): AudioPolicyManager(clientInterface, false /*forTesting*/) { loadConfig(); initialize(
audio_policy.conf说明（翻译）
lininglive的专栏
12-02 3059
转载自：http://www.cnblogs.com/albert1017/p/3940010.html 作者写的很不错，记录下来供以后温故。 # # Audio policy configuration for generic device builds (goldfish audio HAL - emulator) #这是模拟器的Audio policy配置 # #
Android10.0audio_policy_configuration.xml解析
l328873524的博客
04-10 4559
前言 今天我们来分析下AudioPolicyManager的初始化过程，以及它是如何来解析audio_policy_configuration.xml的 正文 先来看看AudioPolicyManager的初始化过程吧，说到AudioPolicyManager那么就得先说AudioPolicyService。 我们知道开机上电后会先执行init rc，audioserver就是通过init rc启...
audio_policy_configure.xml
luckywang1103的专栏
11-18 1006
关于audio_policy_configuration.xml文件的说明 &amp;lt;!-- Modules section: There is one section per audio HW module present on the platform. Each module section will contains two mandatory tags fo...
audio_policy_configuration.xml配置文件详解
wangbuji的博客
08-03 1782
音频策略配置文件
【AudioPolicy To AudioHAL笔记（三）】安卓S上audio_policy_configuration.xml 加载过程分析
芯心智库
02-02 1593
看图应该不难分析，就是套娃又套娃。一个modules对应一个so文件,例如，这个就是对于一个primary HAL；其中一个module允许有多个设备列表。单从函数分析并不难，找到对应模板的名字，然后再调用。本文详细讲一下这个解析配置文件的过程。
加载audio_policy_configuration.xml的函数在哪
05-20
加载audio_policy_configuration.xml的函数在Android Framework中的AudioPolicyManager类中，具体的函数名为loadAudioPolicyConfig()，它定义在AudioPolicyManager.cpp文件中。该函数会读取audio_policy_configuration.xml文件，并将其中的音频策略信息解析成AudioPolicyConfig类的对象。这些音频策略信息会被用于管理设备的音频行为，包括音频路由、音量控制、音效处理等。在Android系统启动时，AudioPolicyManager会自动调用loadAudioPolicyConfig()函数，以便将音频策略信息加载到系统中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值