(总结)音频输出设备的获取流程

最新推荐文章于 2024-06-03 15:12:04 发布
最新推荐文章于 2024-06-03 15:12:04 发布
阅读量2.6k 收藏 17
点赞数
分类专栏： audio 日常总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38091632/article/details/103508998
版权

文章目录

本文根据zhuyong006的音频输出设备是如何决定的文章进行总结。

1 AudioTrack创建时获取output

AudioTrack的函数调用情况如下：

AudioTrack::AudioTrack
	 |- AudioTrack::set
	 	|- AudioTrack::createTrack_l
	 		|- AudioSystem::getOutputForAttr

其中AudioSystem::getOutputForAttr()函数根据attr获取output。

2 getOutputForAttr函数内的获取流程

attr -> strategy -> device -> output

2.1 attr的获取

我们从使用的地方往上推，看看attr是从哪里获取的，参考下上面的函数调用flow。

//AudioTrack.cpp
status_t AudioTrack::createTrack_l()
{
	//attr源于mAttributes 
    audio_attributes_t *attr = (mStreamType == AUDIO_STREAM_DEFAULT) ? &mAttributes : NULL;
    
    status = AudioSystem::getOutputForAttr(attr, &output,
                                           mSessionId, &streamType, mClientUid,
                                           &config,
                                           mFlags, &mRoutedDeviceId, &mPortId);
}


//AudioTrack.h
class AudioTrack : public AudioSystem::AudioDeviceCallback
{
    audio_attributes_t      mAttributes;
}



status_t AudioTrack::set(
        audio_stream_type_t streamType,
        uint32_t sampleRate,
        audio_format_t format,
        audio_channel_mask_t channelMask,
        size_t frameCount,
        audio_output_flags_t flags,
        callback_t cbf,
        void* user,
        int32_t notificationFrames,
        const sp<IMemory>& sharedBuffer,
        bool threadCanCallJava,
        audio_session_t sessionId,
        transfer_type transferType,
        const audio_offload_info_t *offloadInfo,
        uid_t uid,
        pid_t pid,
        const audio_attributes_t* pAttributes,//这里
        bool doNotReconnect,	//默认值
        float maxRequiredSpeed)	//默认值
{
    if (pAttributes == NULL) {
		//······
    } else {
        // stream type shouldn't be looked at, this track has audio attributes
        memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));

		//处理attr
        mStreamType = AUDIO_STREAM_DEFAULT;
        if ((mAttributes.flags & AUDIO_FLAG_HW_AV_SYNC) != 0) {
            flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_HW_AV_SYNC);
        }
        if ((mAttributes.flags & AUDIO_FLAG_LOW_LATENCY) != 0) {
            flags = (audio_output_flags_t) (flags | AUDIO_OUTPUT_FLAG_FAST);
        }
        // check deep buffer after flags have been modified above
        if (flags == AUDIO_OUTPUT_FLAG_NONE && (mAttributes.flags & AUDIO_FLAG_DEEP_BUFFER) != 0) {
            flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
        }

	}
}


AudioTrack::AudioTrack(
        audio_stream_type_t streamType,
        uint32_t sampleRate,
        audio_format_t format,
        audio_channel_mask_t channelMask,
        const sp<IMemory>& sharedBuffer,
        audio_output_flags_t flags,
        callback_t cbf,
        void* user,
        int32_t notificationFrames,
        audio_session_t sessionId,
        transfer_type transferType,
        const audio_offload_info_t *offloadInfo,
        uid_t uid,
        pid_t pid,
        const audio_attributes_t* pAttributes,	//here
        bool doNotReconnect,
        float maxRequiredSpeed)
    : mStatus(NO_INIT),
      mState(STATE_STOPPED),
      mPreviousPriority(ANDROID_PRIORITY_NORMAL),
      mPreviousSchedulingGroup(SP_DEFAULT),
      mPausedPosition(0),
      mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
      mPauseTimeRealUs(0),
      mPortId(AUDIO_PORT_HANDLE_NONE),
      mTrackOffloaded(false)
{
    mStatus = set(streamType, sampleRate, format, channelMask,
            0 /*frameCount*/, flags, cbf, user, notificationFrames,
            sharedBuffer, false /*threadCanCallJava*/, sessionId, transferType, offloadInfo,
            uid, pid, pAttributes, doNotReconnect, maxRequiredSpeed);
}

createTrack_l函数中，判断mStreamType是否为默认值AUDIO_STREAM_DEFAULT，是的话就把mAttributes赋给attr。

createTrack_l()函数没有入参，推断这个mAttributes应该是AudioTrack的成员变量。看来下头文件，确实是，那么再往上看。

set函数中发现是将传入的参数pAttributes按照audio_attributes_t类型赋值给mAttributes。再追踪下构造函数。

构造函数中发现是传入参数，那么确定了attr是由创建audiotrack的时候赋值的，推断应该是应用层传下来，以soundpool为例看下出处。

//soundpool.cpp
void SoundChannel::play(const sp<Sample>& sample, int nextChannelID, float leftVolume,
        float rightVolume, int priority, int loop, float rate)
{
            newTrack = new AudioTrack(streamType, sampleRate, sample->format(),
                    channelMask, frameCount, AUDIO_OUTPUT_FLAG_FAST, callback, userData,
                    bufferFrames, AUDIO_SESSION_ALLOCATE, AudioTrack::TRANSFER_DEFAULT,
                    NULL /*offloadInfo*/, -1 /*uid*/, -1 /*pid*/, mSoundPool->attributes());
}

//soundpool.cpp
class SoundPool {
    const audio_attributes_t* attributes() { return &mAttributes; }
    
	audio_attributes_t      mAttributes;
}

最后一个参数就是attr的由来。（ps：最后两个参数可不写，因为设了默认值）

attributes()函数是soundpool的成员函数，只是获取其成员变量mAttributes。

看下soundpool的构造函数

//audio.h
typedef struct {
    audio_content_type_t content_type;
    audio_usage_t        usage;
    audio_source_t       source;
    audio_flags_mask_t   flags;
    char                 tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE]; /* UTF8 */
} audio_attributes_t;


//SoundPool.cpp
SoundPool::SoundPool(int maxChannels, const audio_attributes_t* pAttributes)
    memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));
}

SoundPool构造函数中将传入的参数pAttributes赋值给成员变量mAttributes。

好的，就追踪到这里，soundpool的创建应该是应用层的，那么确定了，应用层传下attr。

2.2 attr -> strategy

createTrack_l的函数调用flow

AudioTrack::createTrack_l
	|- AudioSystem::getOutputForAttr
		|- AudioPolicyService::getOutputForAttr
			|- AudioPolicyManager::getOutputForAttr
				|- getStrategyForAttr
				|- getDeviceForStrategy
				|- AudioPolicyManager::getOutputForDevice

在这里插入图片描述
createTrack_l中的AudioSystem::getOutputForAttr最终调用到AudioPolicyManager::getOutputForAttr，调用流程可以参考的我另一篇文章：Android获取音频输出getOutput和设置

接下来，我们从getStrategyForAttr看起。

  1. getStrategyForAttr在getOutputForAttr中被调用：
//AudioPolicyManager.cpp
status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
                                              audio_io_handle_t *output,
                                              audio_session_t session,
                                              audio_stream_type_t *stream,
                                              uid_t uid,
                                              const audio_config_t *config,
                                              audio_output_flags_t flags,
                                              audio_port_handle_t *selectedDeviceId,
                                              audio_port_handle_t *portId)
{
	//获取strategy
    routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);
    
    //获取device类型
    audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
    
	//获取output
    *output = getOutputForDevice(device, session, *stream,
                                 config->sample_rate, config->format, config->channel_mask,
                                 flags, &config->offload_info);
}


//routingstrategy.h
enum routing_strategy {
    STRATEGY_MEDIA,	
    STRATEGY_PHONE,	
    STRATEGY_SONIFICATION,	
    STRATEGY_SONIFICATION_RESPECTFUL,
    STRATEGY_DTMF,
    STRATEGY_ENFORCED_AUDIBLE,
    STRATEGY_TRANSMITTED_THROUGH_SPEAKER,
    STRATEGY_ACCESSIBILITY,
    STRATEGY_REROUTING,
    NUM_STRATEGIES
};

头文件中看到了音频路径策略是enum类型，有这几种，最常见的是STRATEGY_MEDIA。

  1. getStrategyForAttr的函数定义
//AudioPolicyManager.cpp
uint32_t AudioPolicyManager::getStrategyForAttr(const audio_attributes_t *attr) {
    // flags to strategy mapping
    if ((attr->flags & AUDIO_FLAG_BEACON) == AUDIO_FLAG_BEACON) {
        return (uint32_t) STRATEGY_TRANSMITTED_THROUGH_SPEAKER;
    }
    if ((attr->flags & AUDIO_FLAG_AUDIBILITY_ENFORCED) == AUDIO_FLAG_AUDIBILITY_ENFORCED) {
        return (uint32_t) STRATEGY_ENFORCED_AUDIBLE;
    }
    // usage to strategy mapping
    return static_cast<uint32_t>(mEngine->getStrategyForUsage(attr->usage));
}

具体调用就不找了，这篇文章写的很好。参考文章

2.3 strategy -> device

  1. 调用
//audio.h
typedef uint32_t audio_devices_t;

//AudioPolicyManager.cpp
status_t AudioPolicyManager::getOutputForAttr(const audio_attributes_t *attr,
                                              audio_io_handle_t *output,
                                              audio_session_t session,
                                              audio_stream_type_t *stream,
                                              uid_t uid,
                                              const audio_config_t *config,
                                              audio_output_flags_t flags,
                                              audio_port_handle_t *selectedDeviceId,
                                              audio_port_handle_t *portId)
{
	audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);
}

注意一下，audio_devices_t变量的类型是uint32_t，这里的device只是设备类型，不是真的device。

  1. getDeviceForStrategy函数定义
audio_devices_t AudioPolicyManager::getDeviceForStrategy(routing_strategy strategy,
                                                         bool fromCache)
{
    // Routing
    // see if we have an explicit route
    // scan the whole RouteMap, for each entry, convert the stream type to a strategy
    // (getStrategy(stream)).
    // if the strategy from the stream type in the RouteMap is the same as the argument above,
    // and activity count is non-zero and the device in the route descriptor is available
    // then select this device.
    for (size_t routeIndex = 0; routeIndex < mOutputRoutes.size(); routeIndex++) {
        sp<SessionRoute> route = mOutputRoutes.valueAt(routeIndex);
        routing_strategy routeStrategy = getStrategy(route->mStreamType);
        if ((routeStrategy == strategy) && route->isActive() &&
                (mAvailableOutputDevices.indexOf(route->mDeviceDescriptor) >= 0)) {
            return route->mDeviceDescriptor->type();
        }
    }

    if (fromCache) {
        ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
              strategy, mDeviceForStrategy[strategy]);
        return mDeviceForStrategy[strategy];
    }
    #if 0
    return mEngine->getDeviceForStrategy(strategy);
    #else
/* OEM 20171027 Jack W Lu, Add Audio Policy Setting {*/
    audio_devices_t device2;
    char project_id[PROPERTY_VALUE_MAX];

    device2 = mEngine->getDeviceForStrategy(strategy);
  //  property_get("ro.product.model", project_id, "");
    if(userManualAudioPolicy != 0)
    {
        ALOGE("enforce User Strategy : %d", userManualAudioPolicy);
        enforceUserStrategy(device2, userManualAudioPolicy);
    }
    ALOGV("proj=%s, device2 = %d", project_id, device2);
    return device2;
    #endif
/* OEM 20171027 Jack W Lu, Add Audio Policy Setting }*/
}

//AudioPolicyManager.h
//头文件中定义了该数组
audio_devices_t mDeviceForStrategy[NUM_STRATEGIES];


//初始化mDeviceForStrategy数组
void AudioPolicyManager::updateDevicesAndOutputs()
{
    for (int i = 0; i < NUM_STRATEGIES; i++) {
        mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
    }
    mPreviousOutputs = mOutputs;
}

getDeviceForStrategy函数就是遍历了mDeviceForStrategy数组，通过strategy获取需要的device。

mDeviceForStrategy的初始化函数被调用我没有查，有空再细看

总结：这里只需要知道通过strategy获取了device 类型。
具体的函数调用查看参考文章。

2.3 device -> output

这个部分可以参考我的文章：Android获取音频输出getOutput和设置

audio_io_handle_t AudioPolicyManager::getOutputForDevice(
        audio_devices_t device,
        audio_session_t session,
        audio_stream_type_t stream,
        uint32_t samplingRate,
        audio_format_t format,
        audio_channel_mask_t channelMask,
        audio_output_flags_t flags,
        const audio_offload_info_t *offloadInfo)
{
	//······
	
non_direct_output:

    if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
        return AUDIO_IO_HANDLE_NONE;
    }

    if (audio_is_linear_pcm(format)) {
        SortedVector<audio_io_handle_t> outputs = getOutputsForDevice(device, mOutputs);

        flags = (audio_output_flags_t)(flags & ~AUDIO_OUTPUT_FLAG_DIRECT);
        output = selectOutput(outputs, flags, format);
    }
    return output;
}

这里有两种情况

  1. 重新打开output，参考我的文章
  2. audiopolicymanager构造函数中打开了outputs中选择一个合适的output

选择方法：
传入的device有对应的outputs表（这些outputs支持该类型的device），根据flags音频标识获取output。

总结：有device类型获取output

outputdevice的定义

audiopolicymanager构造函数中解析了config文件，config文件中包含了特定output下的设备信息，具体的device调用之后再看。

本文本就是对这篇文章的总结，写的比较简单，建议结合该文章进行理解。

飞鸟厌鱼
关注
  • 0
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Audio系统调用流程
martin的专栏
10-08 3398
播放接口：AudioTrack 录制接口：AudioRecord 系统控制接口：AudioSystem Audio系统框架分为三个进程：Audio客户端、main_mediaserver和servicemanager，两个服务：AudioFlinger和AudioPolicyservice；真正干活的都是在两个服务中。   流程介绍 播放流程： 1、AudioTrack::Audio
音频数据流程
J.A.Y的专栏
11-08 2931
在系统启动时MediaSever加载了两个服务：AudioPolicyService和AudioFlinger。   1.3.1 AudioPolicyService AudioPolicyService主要完成以下任务 JAVA应用层通过JNI，经由IAudioPolicyService接口，访问AudioPolicyService提供的服务 输入输出设备的连接状态 系统的音频策略（
Android NDK开发详解连接性之音频管理器自行管理的通话指南
hnjzfwy的博客
11-16 334
原生开发套件 (NDK) 是一套工具，使您能够在 Android 应用中使用 C 和 C++ 代码，并提供众多平台库，您可使用这些平台库管理原生 activity 和访问实体设备组件，例如传感器和触控输入。NDK 可能不适合大多数 Android 编程初学者，这些初学者只需使用 Java 代码和框架 API 开发应用
Android11 AudioTrack 创建过程
最新发布
littleyards的博客
06-03 438
首先，通过声音属性，从mProductStrategies中找到strategy，然后根据strategy，找到对应的device。mOutputs中，支持该device的output可能有多个，通过getOutputsForDevices把它们找出来，然后调用selectOutput从中选择一个最符合的。综上，找到output的流程为： audio_attributes_t >>> strategy >>> device >>> output。2，根据device，找到output。
Audio系统中声音输出设备的getOutput函数的调用流程图
蓝蓝的天
06-28 6413
Audio系统中设置声音输出设备的getOutput函数的调用流程图如下： AudioPolicyClientInterface的派生类只有一个，即AudioPolicyService类。AudioPolicyService的基类有三个，定义如下： class AudioPolicyService: public BnAudioPolicyService, public AudioPo
X-CUBE-USB-AUDIO 资料篇⑦——USB音频播放启动Start流程详解
小康师兄
08-06 1193
X-CUBE-USB-AUDIO 资料篇⑦——USB音频播放启动Start流程详解
音频Open Output业务逻辑
jackzhouyu的专栏
12-24 3768
open output顾名思义，你可以理解为打开一条输出通道，这条通道上跑着一定格式、采样率等特定的数据，通道的终点是一个音频设备，用于播放；所以这个open output业务就是初始化这条通道，为这个通道建立各种所需功能等。
gstreamer之playbin2 aac 音频播放流程
08-30
解码后的音频数据随后会被送入音频转换和音量控制组件，如audioconvert和volume，然后通过音频输出插件（如autoaudiosink）播放到系统的音频设备。 在播放过程中，Playbin2会管理媒体的加载、解码、缓冲、同步和...
webrtc音频数据流流程图
03-16
3. **音频采集**：在客户端，WebRTC使用getUserMedia API获取用户麦克风输入的原始音频数据，这些数据通常是单声道或立体声的PCM（ Pulse Code Modulation）格式。 4. **音频编解码**：采集到的音频数据经过编解码...
获取系统音视频设备
12-29
通过这种方式，我们可以从视频输入设备获取数据，通过编解码器进行处理，然后通过音频输出设备播放。 总的来说，"获取系统音视频设备"涉及的关键技术点包括： 1. 使用DirectShow框架及其核心接口（如`IEnumFilters...
MFC下通过系统API获取麦克风数据并输出到耳机
11-20
在本文中，我们将深入探讨如何在MFC（Microsoft Foundation Classes）环境下，利用系统API来获取麦克风的PCM（Pulse Code Modulation）音频数据，并将其输出到耳机。这对于开发多媒体通信应用，例如语音聊天或录音...
windows 电脑音频检测工具
03-10
首先，我们要理解音频工作流程：声音信号由输入设备（如麦克风）捕捉，经过声卡处理，再由输出设备（如扬声器）播放出来。这个过程中，任何环节出现问题都可能导致音频故障。 在提供的压缩包文件中，有两个关键文件...
WebRTC(三) Web端音视频设备信息获取
simple_a的博客
10-19 1775
1 html代码，用于显示当前设备的信息 <html> <head> <title>WebRTC get audio and video devices</title> </head> <body> <div> <label>audio input device:</labe...
Android音频框架之三 用户录音启动流程源码走读 startRecord
weixin_38387929的博客
03-14 6581
前言 此篇是对《Android音频框架之一 详解audioPolicy流程及HAL驱动加载》 和《Android音频框架之二 用户录音启动流程源码走读》的延续， 此系列博文是记录在Android7.1系统即以后版本实现内录音功能。 当用户使用 AudioRecord 录音 API 创建 new AudioRecord 后，会创建文件流把 AudioRecord 的音频流写入到文件流或网络流中， 调用的方法时 audioRecord.read() 方法，把数据写入到文件流中，源码如下 public class
android ACodec MediaCodec NuPlayer flow
husanlim 的专栏
04-22 4193
MediaCodec/ACodec流程i. 初始化（从java层开始）：1、 java层中调用MediaCodec.createEncoder/DecoderByType(…)或MediaCodec.createByCodecName(…)创建编码器或者解码器2、 根据不同的参数new MediaCodec，然后其中会调用native_setup(…)3、 Native层android_media...
AudioTrack播放音频的流程
ouxie的专栏
08-21 8821
当播放音乐的时候，尤其是缓冲音频数据时，我们会用到AudioTrack类。 首先得new一个对象出来， AudioTrack mPlayer = new AudioTrack(3, 44100, AudioFormat.CHANNEL_IN_STEREO, AudioFormat.ENCODING_PCM_16BIT, mTrackBufflen, 1); 先来看下这个初始化函数中做了哪些事
audiotrack android,如何在Android中获取AudioTrack的音量？
weixin_36095188的博客
05-29 472
我可以使用track.setStereoVolume(a,b);来设置audioTrack的音量.但是我找不到像getStereoVolume()或setOnVolumeChangedHandler(…)这样的获取音量的方法.如何追踪音量？解决方法:您无法获得音轨的左右音量.因此,我建议您创建一个表示AudioTrack的类.public class AudioPlayer{AudioTrack ...
音视频播放器设计（四）——ffmpeg音频处理流程
www_dong的博客
06-16 813
QAudioFormat：设置音频的格式相关信息，如采样率、采样位数、通道数等信息。QAudioOutput：控制音频的播放、暂停、设置和获取音量等。QIODevice：所有输入输出IO类的基础类,为IO类提供了统一的调用接口。 停止音频 音频播放 使用QAudioOutput的接口resume/suspend来恢复/继续播放音频。 音频写入缓冲 音频解码 查找解码器 音频解码 通过avcodec_send_packet接口同时发送音视频，avcodec_receive_frame接收解码后的数据。通
Android音频子系统（五）------AudioFlinger处理流程
风筝
03-15 2907
播放线程的基类都是Thread， classThread : virtual public RefBase (system/core/include/utils/Thread.h) class ThreadBase : public Thread（frameworks/av/services/audioflinger/Threads.h） class PlaybackThread : public ThreadBase（frameworks/av/services/audioflinger/Threads
数字新媒体技术：从获取到输出的关键流程
例如，键盘、鼠标等传统输入设备，以及数码相机、数字摄像机、扫描仪等专门用于图像获取的设备，还有声音系统用于语音和音频输入与合成。此外，人机交互技术如触摸屏、数据手套和数据衣等进一步增强了用户与数字内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值