Android音频(三)AudioPolicyService

最新推荐文章于 2024-05-29 18:14:10 发布
最新推荐文章于 2024-05-29 18:14:10 发布
阅读量586 收藏 1
点赞数
分类专栏： android 源码

原址

AudioPolicyService是策略的制定者，比如什么时候打开音频接口设备、某种Stream类型的音频对应什么设备等等。而AudioFlinger则是策略的执行者，例如具体如何与音频设备通信，如何维护现有系统中的音频设备，以及多个音频流的混音如何处理等等都得由它来完成。AudioPolicyService根据用户配置来指导AudioFlinger加载设备接口，起到路由功能。

AudioPolicyService启动过程

AudioPolicyService服务运行在mediaserver进程中，随着mediaserver进程启动而启动。

frameworks\av\media\mediaserver\ Main_mediaserver.cpp

[cpp]  view plain  copy
  1. int main(int argc, char** argv)  
  2. {  
  3.     sp<ProcessState> proc(ProcessState::self());  
  4.     sp<IServiceManager> sm = defaultServiceManager();  
  5.     ALOGI("ServiceManager: %p", sm.get());  
  6.     VolumeManager::instantiate(); // volumemanager have to be started before audioflinger  
  7.     AudioFlinger::instantiate();  
  8.     MediaPlayerService::instantiate();  
  9.     CameraService::instantiate();  
  10.     AudioPolicyService::instantiate();  
  11.     ProcessState::self()->startThreadPool();  
  12.     IPCThreadState::self()->joinThreadPool();  
  13. }  

AudioPolicyService继承了模板类BinderService，该类用于注册native service。

frameworks\native\include\binder\ BinderService.h

[cpp]  view plain  copy
  1. template<typename SERVICE>  
  2. class BinderService  
  3. {  
  4. public:  
  5.     static status_t publish(bool allowIsolated = false) {  
  6.         sp<IServiceManager> sm(defaultServiceManager());  
  7.         return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);  
  8.     }  
  9.     static void instantiate() { publish(); }  
  10. };  

BinderService是一个模板类，该类的publish函数就是完成向ServiceManager注册服务。

[cpp]  view plain  copy
  1. static const char *getServiceName() { return "media.audio_policy"; }  

AudioPolicyService注册名为media.audio_policy的服务。

[cpp]  view plain  copy
  1. AudioPolicyService::AudioPolicyService()  
  2.     : BnAudioPolicyService() , mpAudioPolicyDev(NULL) , mpAudioPolicy(NULL)  
  3. {  
  4.     char value[PROPERTY_VALUE_MAX];  
  5.     const struct hw_module_t *module;  
  6.     int forced_val;  
  7.     int rc;  
  8.     Mutex::Autolock _l(mLock);  
  9.     // start tone playback thread  
  10.     mTonePlaybackThread = new AudioCommandThread(String8("ApmTone"), this);  
  11.     // start audio commands thread  
  12.     mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);  
  13.     // start output activity command thread  
  14.     mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);  
  15.     /* instantiate the audio policy manager */  
  16.     /* 加载audio_policy.default.so库得到audio_policy_module模块 */  
  17.     rc = hw_get_module(AUDIO_POLICY_HARDWARE_MODULE_ID, &module);  
  18.     if (rc)  
  19.         return;  
  20.     /* 通过audio_policy_module模块打开audio_policy_device设备 */  
  21.     rc = audio_policy_dev_open(module, &mpAudioPolicyDev);  
  22.     ALOGE_IF(rc, "couldn't open audio policy device (%s)", strerror(-rc));  
  23.     if (rc)  
  24.         return;  
  25.     //通过audio_policy_device设备创建audio_policy  
  26.     rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this,  
  27.                                                &mpAudioPolicy);  
  28.     ALOGE_IF(rc, "couldn't create audio policy (%s)", strerror(-rc));  
  29.     if (rc)  
  30.         return;  
  31.     rc = mpAudioPolicy->init_check(mpAudioPolicy);  
  32.     ALOGE_IF(rc, "couldn't init_check the audio policy (%s)", strerror(-rc));  
  33.     if (rc)  
  34.         return;  
  35.     /* SPRD: maybe set this property better, but here just change the default value @{ */  
  36.     property_get("ro.camera.sound.forced", value, "1");  
  37.     forced_val = strtol(value, NULL, 0);  
  38.     ALOGV("setForceUse() !forced_val=%d ",!forced_val);  
  39.     mpAudioPolicy->set_can_mute_enforced_audible(mpAudioPolicy, !forced_val);  
  40.     ALOGI("Loaded audio policy from %s (%s)", module->name, module->id);  
  41.     // 读取audio_effects.conf文件  
  42.     if (access(AUDIO_EFFECT_VENDOR_CONFIG_FILE, R_OK) == 0) {  
  43.         loadPreProcessorConfig(AUDIO_EFFECT_VENDOR_CONFIG_FILE);  
  44.     } else if (access(AUDIO_EFFECT_DEFAULT_CONFIG_FILE, R_OK) == 0) {  
  45.         loadPreProcessorConfig(AUDIO_EFFECT_DEFAULT_CONFIG_FILE);  
  46.     }  
  47. }  
  1. 创建AudioCommandThread (ApmTone、ApmAudio、ApmOutput)
  2. 加载legacy_ap_module
  3. 打开legacy_ap_device
  4. 创建legacy_audio_policy
  5. 读取audio_effects.conf

创建AudioCommandThread线程

在AudioPolicyService对象构造过程中，分别创建了ApmTone、ApmAudio、ApmOutput三个AudioCommandThread线程：

1、 ApmTone用于播放tone音；

2、 ApmAudio用于执行audio命令；

3、ApmOutput用于执行输出命令；

在第一次强引用AudioCommandThread线程对象时，AudioCommandThread的onFirstRef函数被回调，在此启动线程

[cpp]  view plain  copy
  1. void AudioPolicyService::AudioCommandThread::onFirstRef()  
  2. {  
  3.     run(mName.string(), ANDROID_PRIORITY_AUDIO);  
  4. }  

这里采用异步方式来执行audio command，当需要执行上表中的命令时，首先将命令投递到AudioCommandThread的mAudioCommands命令向量表中，然后通过mWaitWorkCV.signal()唤醒AudioCommandThread线程，被唤醒的AudioCommandThread线程执行完command后，又通过mWaitWorkCV.waitRelative(mLock, waitTime)睡眠等待命令到来。

加载audio_policy_module模块

audio_policy硬件抽象层动态库位于/system/lib/hw/目录下，命名为：audio_policy.$(TARGET_BOARD_PLATFORM).so。audiopolicy的硬件抽象层定义在hardware\libhardware_legacy\audio\audio_policy_hal.cpp中，AUDIO_POLICY_HARDWARE_MODULE_ID硬件抽象模块定义如下：

hardware\libhardware_legacy\audio\ audio_policy_hal.cpp【audio_policy.scx15.so】

[cpp]  view plain  copy
  1. struct legacy_ap_module HAL_MODULE_INFO_SYM = {  
  2.     module: {  
  3.         common: {  
  4.             tag: HARDWARE_MODULE_TAG,  
  5.             version_major: 1,  
  6.             version_minor: 0,  
  7.             id: AUDIO_POLICY_HARDWARE_MODULE_ID,  
  8.             name: "LEGACY Audio Policy HAL",  
  9.             author: "The Android Open Source Project",  
  10.             methods: &legacy_ap_module_methods,  
  11.             dso : NULL,  
  12.             reserved : {0},  
  13.         },  
  14.     },  
  15. };  

legacy_ap_module继承于audio_policy_module。


 

关于hw_get_module函数加载硬件抽象层模块的过程请参考Android硬件抽象Hardware库加载过程源码分析。

打开audio_policy_device设备

hardware\libhardware\include\hardware\ audio_policy.h

[cpp]  view plain  copy
  1. static inline int audio_policy_dev_open(const hw_module_t* module,  
  2.                                     struct audio_policy_device** device)  
  3. {  
  4.     return module->methods->open(module, AUDIO_POLICY_INTERFACE,  
  5.                                  (hw_device_t**)device);  
  6. }  

通过legacy_ap_module模块的open方法来打开一个legacy_ap_device设备。

hardware\libhardware_legacy\audio\ audio_policy_hal.cpp

[cpp]  view plain  copy
  1. static int legacy_ap_dev_open(const hw_module_t* module, const char* name,  
  2.                                     hw_device_t** device)  
  3. {  
  4.     struct legacy_ap_device *dev;  
  5.     if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0)  
  6.         return -EINVAL;  
  7.     dev = (struct legacy_ap_device *)calloc(1, sizeof(*dev));  
  8.     if (!dev)  
  9.         return -ENOMEM;  
  10.     dev->device.common.tag = HARDWARE_DEVICE_TAG;  
  11.     dev->device.common.version = 0;  
  12.     dev->device.common.module = const_cast<hw_module_t*>(module);  
  13.     dev->device.common.close = legacy_ap_dev_close;  
  14.     dev->device.create_audio_policy = create_legacy_ap;  
  15.     dev->device.destroy_audio_policy = destroy_legacy_ap;  
  16.     *device = &dev->device.common;  
  17.     return 0;  
  18. }  

打开得到一个legacy_ap_device设备，通过该抽象设备可以创建一个audio_policy对象。

创建audio_policy对象

在打开legacy_ap_device设备时，该设备的create_audio_policy成员初始化为create_legacy_ap函数指针，我们通过legacy_ap_device设备可以创建一个legacy_audio_policy对象。

[cpp]  view plain  copy
  1. rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this,  
  2.                                                &mpAudioPolicy);  

这里通过audio_policy_device设备创建audio策略对象

hardware\libhardware_legacy\audio\ audio_policy_hal.cpp

[cpp]  view plain  copy
  1. static int create_legacy_ap(const struct audio_policy_device *device,  
  2.                             struct audio_policy_service_ops *aps_ops,  
  3.                             void *service,  
  4.                             struct audio_policy **ap)  
  5. {  
  6.     struct legacy_audio_policy *lap;  
  7.     int ret;  
  8.     if (!service || !aps_ops)  
  9.         return -EINVAL;  
  10.     lap = (struct legacy_audio_policy *)calloc(1, sizeof(*lap));  
  11.     if (!lap)  
  12.         return -ENOMEM;  
  13. lap->policy.set_device_connection_state = ap_set_device_connection_state;  
  14. …  
  15.     lap->policy.dump = ap_dump;  
  16.     lap->policy.is_offload_supported = ap_is_offload_supported;  
  17.     lap->service = service;  
  18.     lap->aps_ops = aps_ops;  
  19.     lap->service_client = new AudioPolicyCompatClient(aps_ops, service);  
  20.     if (!lap->service_client) {  
  21.         ret = -ENOMEM;  
  22.         goto err_new_compat_client;  
  23.     }  
  24.     lap->apm = createAudioPolicyManager(lap->service_client);  
  25.     if (!lap->apm) {  
  26.         ret = -ENOMEM;  
  27.         goto err_create_apm;  
  28.     }  
  29.     *ap = &lap->policy;  
  30.     return 0;  
  31. err_create_apm:  
  32.     delete lap->service_client;  
  33. err_new_compat_client:  
  34.     free(lap);  
  35.     *ap = NULL;  
  36.     return ret;  
  37. }  

audio_policy实现在audio_policy_hal.cpp中，audio_policy_service_ops实现在AudioPolicyService.cpp中。create_audio_policy()函数就是创建并初始化一个legacy_audio_policy对象。

audio_policy与AudioPolicyService、AudioPolicyCompatClient之间的关系如下：

AudioPolicyClient创建

hardware\libhardware_legacy\audio\ AudioPolicyCompatClient.h

[cpp]  view plain  copy
  1. AudioPolicyCompatClient(struct audio_policy_service_ops *serviceOps,void *service) :  
  2.         mServiceOps(serviceOps) , mService(service) {}  

AudioPolicyCompatClient是对audio_policy_service_ops的封装类，对外提供audio_policy_service_ops数据结构中定义的接口。

AudioPolicyManager创建
[cpp]  view plain  copy
  1. extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)  
  2. {  
  3.     ALOGI("SPRD policy manager created.");  
  4.     return new AudioPolicyManagerSPRD(clientInterface);  
  5. }  

使用AudioPolicyClientInterface对象来构造AudioPolicyManagerSPRD对象，AudioPolicyManagerSPRD继承于AudioPolicyManagerBase，而AudioPolicyManagerBase又继承于AudioPolicyInterface。

hardware\libhardware_legacy\audio\ AudioPolicyManagerBase.cpp

[cpp]  view plain  copy
  1. AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clientInterface)  
  2.     :  
  3. #ifdef AUDIO_POLICY_TEST  
  4.     Thread(false),  
  5. #endif //AUDIO_POLICY_TEST  
  6.     //变量初始化  
  7.     mPrimaryOutput((audio_io_handle_t)0),  
  8.     mAvailableOutputDevices(AUDIO_DEVICE_NONE),  
  9.     mPhoneState(AudioSystem::MODE_NORMAL),  
  10.     mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),  
  11.     mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0),  
  12.     mA2dpSuspended(false), mHasA2dp(false), mHasUsb(false), mHasRemoteSubmix(false),  
  13.     mSpeakerDrcEnabled(false), mFmOffGoing(false)  
  14. {  
  15.     //引用AudioPolicyCompatClient对象，这样音频管理器AudioPolicyManager就可以使用audio_policy_service_ops中的接口  
  16.     mpClientInterface = clientInterface;  
  17.     for (int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {  
  18.         mForceUse[i] = AudioSystem::FORCE_NONE;  
  19.     }  
  20.     mA2dpDeviceAddress = String8("");  
  21.     mScoDeviceAddress = String8("");  
  22.     mUsbCardAndDevice = String8("");  
  23.     /** 
  24.      * 优先加载/vendor/etc/audio_policy.conf配置文件，如果该配置文件不存在，则 
  25.      * 加载/system/etc/audio_policy.conf配置文件，如果该文件还是不存在，则通过 
  26.      * 函数defaultAudioPolicyConfig()来设置默认音频接口 
  27.      */  
  28.     if (loadAudioPolicyConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE) != NO_ERROR) {  
  29.         if (loadAudioPolicyConfig(AUDIO_POLICY_CONFIG_FILE) != NO_ERROR) {  
  30.             ALOGE("could not load audio policy configuration file, setting defaults");  
  31.             defaultAudioPolicyConfig();  
  32.         }  
  33.     }  
  34.     //设置各种音频流对应的音量调节点,must be done after reading the policy  
  35.     initializeVolumeCurves();  
  36.     // open all output streams needed to access attached devices  
  37.     for (size_t i = 0; i < mHwModules.size(); i++) {  
  38.         //通过名称打开对应的音频接口硬件抽象库  
  39.         mHwModules[i]->mHandle = mpClientInterface->loadHwModule(mHwModules[i]->mName);  
  40.         if (mHwModules[i]->mHandle == 0) {  
  41.             ALOGW("could not open HW module %s", mHwModules[i]->mName);  
  42.             continue;  
  43.         }  
  44.         // open all output streams needed to access attached devices  
  45.         // except for direct output streams that are only opened when they are actually  
  46.         // required by an app.  
  47.         for (size_t j = 0; j < mHwModules[i]->mOutputProfiles.size(); j++)  
  48.         {  
  49.             const IOProfile *outProfile = mHwModules[i]->mOutputProfiles[j];  
  50.             //打开mAttachedOutputDevices对应的输出  
  51.             if ((outProfile->mSupportedDevices & mAttachedOutputDevices) &&  
  52.                     ((outProfile->mFlags & AUDIO_OUTPUT_FLAG_DIRECT) == 0)) {  
  53.                 //将输出IOProfile封装为AudioOutputDescriptor对象  
  54.                 AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor(outProfile);  
  55.                 //设置当前音频接口的默认输出设备  
  56.                 outputDesc->mDevice = (audio_devices_t)(mDefaultOutputDevice & outProfile->mSupportedDevices);  
  57.                 //打开输出，在AudioFlinger中创建PlaybackThread线程，并返回该线程的id  
  58.                 audio_io_handle_t output = mpClientInterface->openOutput(  
  59.                                                 outProfile->mModule->mHandle,  
  60.                                                 &outputDesc->mDevice,  
  61.                                                 &outputDesc->mSamplingRate,  
  62.                                                 &outputDesc->mFormat,  
  63.                                                 &outputDesc->mChannelMask,  
  64.                                                 &outputDesc->mLatency,  
  65.                                                 outputDesc->mFlags);  
  66.                 if (output == 0) {  
  67.                     delete outputDesc;  
  68.                 } else {  
  69.                     //设置可以使用的输出设备为mAttachedOutputDevices  
  70.                     mAvailableOutputDevices =(audio_devices_t)(mAvailableOutputDevices | (outProfile->mSupportedDevices & mAttachedOutputDevices));  
  71.                     if (mPrimaryOutput == 0 && outProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) {  
  72.                         mPrimaryOutput = output;  
  73.                     }  
  74.                     //将输出描述符对象AudioOutputDescriptor及创建的PlaybackThread线程id以键值对形式保存  
  75.                     addOutput(output, outputDesc);  
  76.                     //设置默认输出设备  
  77.                     setOutputDevice(output,(audio_devices_t)(mDefaultOutputDevice & outProfile->mSupportedDevices),true);  
  78.                 }  
  79.             }  
  80.         }  
  81.     }  
  82.     ALOGE_IF((mAttachedOutputDevices & ~mAvailableOutputDevices),  
  83.              "Not output found for attached devices %08x",  
  84.              (mAttachedOutputDevices & ~mAvailableOutputDevices));  
  85.     ALOGE_IF((mPrimaryOutput == 0), "Failed to open primary output");  
  86.     updateDevicesAndOutputs();  
  87.   
  88.     //  add for bug158794 start  
  89.     char bootvalue[PROPERTY_VALUE_MAX];  
  90.     // prop sys.boot_completed will set 1 when system ready (ActivityManagerService.java)...  
  91.     property_get("sys.boot_completed", bootvalue, "");  
  92.     if (strncmp("1", bootvalue, 1) != 0) {  
  93.         startReadingThread();  
  94.     }  
  95.     // add for bug158794 end  
  96.   
  97. #ifdef AUDIO_POLICY_TEST  
  98.     ...  
  99. #endif //AUDIO_POLICY_TEST  
  100. }  

AudioPolicyManagerBase对象构造过程中主要完成以下几个步骤：

1、  loadAudioPolicyConfig(AUDIO_POLICY_CONFIG_FILE)加载audio_policy.conf配置文件；

2、  initializeVolumeCurves()初始化各种音频流对应的音量调节点；

3、  加载audio policy硬件抽象库：mpClientInterface->loadHwModule(mHwModules[i]->mName)

4、  打开attached_output_devices输出：

mpClientInterface->openOutput()；

5、  保存输出设备描述符对象：addOutput(output, outputDesc);

读取audio_policy.conf文件

Android为每种音频接口定义了对应的硬件抽象层，且编译为单独的so库。

每种音频接口定义了不同的输入输出，一个接口可以具有多个输入或者输出，每个输入输出有可以支持不同的音频设备。通过读取audio_policy.conf文件可以获取系统支持的音频接口参数。

audio_policy.conf文件定义了两种音频配置信息：

1、  当前系统支持的音频输入输出设备及默认输入输出设备；

这些信息时通过global_configuration配置项来设置，在global_configuration中定义了三种音频设备信息：

attached_output_devices：已连接的输出设备；

default_output_device：默认输出设备；

attached_input_devices：已连接的输入设备；

 

1、  系统支持的音频接口信息；

audio_policy.conf定义了系统支持的所有音频接口参数信息，比如primary、a2dp、usb等，对于primary定义如下：

a2dp定义：

usb定义：

每种音频接口包含输入输出，每种输入输出又包含多种输入输出配置，每种输入输出配置又支持多种音频设备。AudioPolicyManagerBase首先加载/vendor/etc/audio_policy.conf，如果该文件不存在，则加/system/etc/audio_policy.conf。

[cpp]  view plain  copy
  1. status_t AudioPolicyManagerBase::loadAudioPolicyConfig(const char *path)  
  2. {  
  3.     cnode *root;  
  4.     char *data;  
  5.     data = (char *)load_file(path, NULL);  
  6.     if (data == NULL) {  
  7.         return -ENODEV;  
  8.     }  
  9.     root = config_node("", "");  
  10.     //读取配置文件  
  11.     config_load(root, data);  
  12.     //解析global_configuration  
  13.     loadGlobalConfig(root);  
  14.     //解析audio_hw_modules  
  15.     loadHwModules(root);  
  16.     config_free(root);  
  17.     free(root);  
  18.     free(data);  
  19.     ALOGI("loadAudioPolicyConfig() loaded %s\n", path);  
  20.     return NO_ERROR;  
  21. }  

通过loadGlobalConfig(root)函数来读取这些全局配置信息。

[cpp]  view plain  copy
  1. void AudioPolicyManagerBase::loadGlobalConfig(cnode *root)  
  2. {  
  3.     cnode *node = config_find(root, GLOBAL_CONFIG_TAG);  
  4.     if (node == NULL) {  
  5.         return;  
  6.     }  
  7.     node = node->first_child;  
  8.     while (node) {  
  9.         //attached_output_devices AUDIO_DEVICE_OUT_EARPIECE  
  10.         if (strcmp(ATTACHED_OUTPUT_DEVICES_TAG, node->name) == 0) {  
  11.             mAttachedOutputDevices = parseDeviceNames((char *)node->value);  
  12.             ALOGW_IF(mAttachedOutputDevices == AUDIO_DEVICE_NONE,  
  13.                     "loadGlobalConfig() no attached output devices");  
  14.             ALOGV("loadGlobalConfig()mAttachedOutputDevices%04x", mAttachedOutputDevices);  
  15.         //default_output_device AUDIO_DEVICE_OUT_SPEAKER  
  16.         } else if (strcmp(DEFAULT_OUTPUT_DEVICE_TAG, node->name) == 0) {  
  17.             mDefaultOutputDevice= (audio_devices_t)stringToEnum(sDeviceNameToEnumTable,ARRAY_SIZE(sDeviceNameToEnumTable),(char *)node->value);  
  18.             ALOGW_IF(mDefaultOutputDevice == AUDIO_DEVICE_NON
无崖
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Android Audio】dumpsys media.audio_policy分析【不定期更新文章】
...
05-31 3998
命令： dumpsys media.audio_policy AudioPolicyManager: 0xf1e5a000 Command Thread: 0xf1ff3300 Supported System Usages: AudioCommandThread 0xf1ff3300 Dump - Commands: Command Time Wait pParam Last Command 01 014581.648 0 0xf19e5440 Aud.
Ubuntu18.04上编译AOSP最新版(Android Pie)遇到的问题及解决方法
Cbcwestwolf的博客
11-29 5938
在使用Ubuntu18.04 编译(build) AOSP时，遇到了以下错误。 一开始我选择lunch的是aosp_arm64-eng，即： source build/envsetup.sh lunch aosp_arm64-eng make -j16 #取决于机器的cpu核心数量 emulator 但是运行emulator之后，在输出信息没有error或者failed的情况下，emulator...
Android 11 AudioPolicyService 启动流程
最新发布
littleyards的博客
05-29 957
在打开输出流的过程中，会得到HAL层的audio_stream_out对象，并将其保存在AudioStreamOut中，创建播放线程的时候，传入该AudioStreamOut,最后将播放线程保存到mPlaybackThreads中。在打开输出流的过程中，会得到HAL层的audio_stream_in对象，并将其保存在AudioStreamIn中，创建录音线程的时候，传入该AudioStreamIn。这个流程和上面的是一样的，最终调用到AudioFlinger的openInput_l处理。
深入剖析Android音频之AudioPolicyService
热门推荐
深入剖析Android系统
09-23 3万+
AudioPolicyService是策略的制定者，比如什么时候打开音频接口设备、某种Stream类型的音频对应什么设备等等。而AudioFlinger则是策略的执行者，例如具体如何与音频设备通信，如何维护现有系统中的音频设备，以及多个音频流的混音如何处理等等都得由它来完成。AudioPolicyService根据用户配置来指导AudioFlinger加载设备接口，起到路由功能。
Android-音频配置文件详解
cheriyou_的博客
03-03 2980
前言: 　　Android P 引入了一种新的音频政策配置文件格式 (XML)，用于描述音频拓扑。新的 XML 文件支持定义输出输入流配置文件、可用于播放和捕获的设备以及音频属性的数量和类型。但是每个项目的代码里面都有很多音频配置文件，具体使用的是哪个文件呢？本文将详细讲述。 1. 查看运行时具体使用的xml adb shell dumpsys media.audio_policy | grep -iE "Config source:" 结果如下: Config source: /vendor
Android音频系统之AudioPolicyService
林学森的技术专栏
04-15 2万+
1.1 AudioPolicy Service 在AudioFlinger小节，我们反复强调它只是策略的执行者，而AudioPolicyService则是策略的制定者。这种分离方式有效地降低了整个系统的藕合性，而且为各个模块独立扩展功能提供了保障。 1.1.1 AudioPolicyService概述 汉语中有很多与策略有关联的俗语，比如“因地制宜”、“具体问题具体分析”;战争中只遵照兵书制
Android音频系统之AudioFlinger(三)
林学森的技术专栏
04-15 1万+
1.1.1 PlaybackThread的循环主体 当一个PlaybackThread进入主循环后(threadLoop),音频事务就正式开启了。仔细观察的话，我们会发现这个循环中会不断地调用以“threadLoop_”开头的若干接口，比如threadLoop_mix、threadLoop_sleepTime、threadLoop_standby等等。以这样的前缀开头，是因为这些函数都是在thr
Android音频详解.pdf
11-28
这个文档是我整理别人博客的，写的非常的不错，通俗易懂，相对来说还是比较全面，讲了linux下的声卡，Android音频 ， AudioPolicyService， AudioFlinger， AudioTrack这些都有详细的讲解，然后我也做了书签，方便...
Android audio知识总结.pdf
10-14
本文将深入探讨Android音频框架，特别是AudioTrack、AudioRecord、AudioSystem、AudioPolicyService、AudioFlinger以及Audio HAL，并讨论它们在音视频处理中的作用。 1. AudioTrack： AudioTrack是Android应用程序...
android_Audio系统.docx
07-04
首先，AudioRecord和AudioTrack是Android音频系统的对外接口，它们提供了Java层的API，使得开发者能够方便地进行音频数据的采集和播放。AudioRecord用于录制音频数据，而AudioTrack则负责播放这些数据。AudioRecord...
Android-audio系统第一季.pdf
10-02
Android音频系统是其操作系统中的一个重要组成部分，主要负责处理声音的播放、录制以及系统级别的声音管理。在这个系统中，有三个核心组件：AudioManager、AudioTrack和AudioRecord。 AudioManager是音频系统的管理...
audio上层框架介绍
10-29
本文将深入探讨Android音频上层框架，特别是AudioFlinger和AudioPolicyService，以及它们如何与硬件交互。 AudioFlinger是Android音频系统的核心组件，负责音频的混合、路由和硬件交互。IAudioFlinger.cpp是Audio...
Android7.1修改系统配置文件默认听筒输出所有声音
回忆
11-14 4424
前言 2014年的买的旧手机到现在一直在捣腾，尽管厂商已经时隔很多年没有更新过系统了，于是自己刷了魔趣的7.1的系统，不得不说原生android系统比手机厂商二次定制过的系统要流畅很多，但是在去年这只陪伴了很多年的旧手机终于出现了问题，扬声器没有声音了，于是拆开手机检查了半天，没有发现任何烧坏的痕迹，拆下扬声器测试也是好的，可能是尾插主板坏了吧，刮了下扬声器触点重新安上还是没有声音，没办法了，于是就想能否用听筒来播放所有声音呢？百度了下还真有这样的软件，于是就随便下了个app，点击切换成听筒模式，..
Android AudioSystem模块分析
Tony的专栏
10-16 4846
Android 音频系统中存在两个重要的服务AudioPolicyService和AudioFlinger，其服务名称为“media.audio_policy”， “media.audio_flinger”。两个服务各司其职，一个负责 音频策略相关，一个负责音频的采集和输出相关。两个服务均在多媒体服务mediaserver中进行注册(main_mediaserver.cpp)。本篇主要分析Aud
售后重启不开机
u012900947的博客
01-03 2367
一、背景介绍 售后机器不开机，经分析是分区损坏导致异常发生 二、分析过程 1.  从现象上看是手机有些是卡在开机动画或者开机第一帧反复重启或者不开机 2. 卡在第一帧的（一是卡在lk logo，二是卡在kernel log）需要打印出来串口log分析，卡在开机动画的可以抓取离线log（mtk平台在不开机状态下可以用GAT工具抓取） 第一种情况： 在优化第N个应用，优化到最后一个
【音视频播放】一、播放基础流程及相关服务
qq_38091632的博客
01-18 8850
前言 安利一个音视频博主，他的博文写的很详细。本博文只是简单介绍大致的播放流程。 1 播放音视频文件流程 图片来源 音视频播放流程: 获取音视频来源source（本地文件或者链接） 分离出source中的音频和视频extractor 对音视频数据进行解码decoder 解码后的数据进行渲染render（其中包含音视频同步） 渲染后的数据交给device播放 大致流程就这，建议先熟悉这个流程图再结合代码看，代码是实现的那一部分的功能。 2 media相关服务 2.1 查看命令 2.1.1 servic
Android 8.1 Audio框架(一)初始化分析
我将带头加班的博客
07-19 7677
AudioPolicyService和它的总管AudioPolicyManager的初始化 类简介： 1.AudioPolicyService：APS是音频框架的服务，在Main_audioserver.cpp中生成，它在第一次强引用的时候会创建AudioCommandThread和AudioPolicyClient，AudioPolicyManager。它主要由AudioSystem通过bind...
cm10.2和cm11源码问题集合
DaoDivDiFang的博客
05-12 825
说明 应该是2016年之前的记录，之前没有写文档记录的习惯，都是随手记录的txt文件，所以没有图片、格式等。甚至现在看来有些地方逻辑不通(可能还因为年少轻狂，有些偏颇的话语)，但是这些与现在的我不重要了，所以也不打算再复现、推理，重新编辑等，仅仅是在旧硬盘中发现，删除之前觉得可能还有点价值，记录下来吧。 均以小米2为环境测试。 10.2: 1:参见ubuntu文档目录的安卓源码编译，下载；cm官方的清单有些安卓分支没有了，需要改分支。 2：使用如下分支产生的问题，这个原本是好不容易找到的以前秋叶的cm10.
Android 音频架构
05-18
2. AudioPolicyService：用于管理音频输入和输出策略的服务，包括音频路由、音量控制、音频焦点等。 3. Audio HAL：硬件抽象层，用于与硬件驱动程序进行通信，以便 Android 系统能够使用各种不同的音频硬件设备。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值