Android13 AudioFlinger createRecord流程分析

原创 已于 2024-05-27 22:01:25 修改 · 1.1k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android

于 2024-05-07 17:22:00 首次发布

AudioFlinger在进行RecordTrack相关操作时需要先创建RecordTrack，在JAVA层AudioRecord的构造函数中会通过JNI调用C++层AudioRecord的set函数，在AudioRecord的set函数中会调用通过AudioSystem获取IAudioFlinger，然后调用AudioFlinger的createRecord函数，从AudioRecord到IAudioFlinger的部分在AudioRecord已经分析过了，下面我们继续分析AudioFlinger的部分：

RecordTrack在AudioFlinger的createRecord函数中调用：

//frameworks/av/services/audioflinger/AudioFlinger.cpp
status_t AudioFlinger::createRecord(const media::CreateRecordRequest& _input,
                                    media::CreateRecordResponse& _output)
{
    CreateRecordInput input = VALUE_OR_RETURN_STATUS(CreateRecordInput::fromAidl(_input));
    CreateRecordOutput output;


    sp<RecordThread::RecordTrack> recordTrack;
    sp<RecordHandle> recordHandle;
    sp<Client> client;
    status_t lStatus;
    audio_session_t sessionId = input.sessionId;
    audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;


    output.cblk.clear();
    output.buffers.clear();
    output.inputId = AUDIO_IO_HANDLE_NONE;


    // TODO b/182392553: refactor or clean up
    AttributionSourceState adjAttributionSource = input.clientInfo.attributionSource;
    bool updatePid = (adjAttributionSource.pid == -1);
    const uid_t callingUid = IPCThreadState::self()->getCallingUid();
    const uid_t currentUid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(
           adjAttributionSource.uid));
    if (!isAudioServerOrMediaServerUid(callingUid)) {
        ALOGW_IF(currentUid != callingUid,
                "%s uid %d tried to pass itself off as %d",
                __FUNCTION__, callingUid, currentUid);
        adjAttributionSource.uid = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(callingUid));
        updatePid = true;
    }
    const pid_t callingPid = IPCThreadState::self()->getCallingPid();
    const pid_t currentPid = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_pid_t(
            adjAttributionSource.pid));
    if (updatePid) {
        ALOGW_IF(currentPid != (pid_t)-1 && currentPid != callingPid,
                 "%s uid %d pid %d tried to pass itself off as pid %d",
                 __func__, callingUid, callingPid, currentPid);
        adjAttributionSource.pid = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(callingPid));
    }


    // we don't yet support anything other than linear PCM
    if (!audio_is_valid_format(input.config.format) || !audio_is_linear_pcm(input.config.format)) {
        ALOGE("createRecord() invalid format %#x", input.config.format);
        lStatus = BAD_VALUE;
        goto Exit;
    }


    // further channel mask checks are performed by createRecordTrack_l()
    if (!audio_is_input_channel(input.config.channel_mask)) {
        ALOGE("createRecord() invalid channel mask %#x", input.config.channel_mask);
        lStatus = BAD_VALUE;
        goto Exit;
    }


    if (sessionId == AUDIO_SESSION_ALLOCATE) {
        sessionId = (audio_session_t) newAudioUniqueId(AUDIO_UNIQUE_ID_USE_SESSION);
    } else if (audio_unique_id_get_use(sessionId) != AUDIO_UNIQUE_ID_USE_SESSION) {
        lStatus = BAD_VALUE;
        goto Exit;
    }


    output.sessionId = sessionId;
    output.selectedDeviceId = input.selectedDeviceId;
    output.flags = input.flags;


    client = registerPid(VALUE_OR_FATAL(aidl2legacy_int32_t_pid_t(adjAttributionSource.pid)));


    // Not a conventional loop, but a retry loop for at most two iterations total.
    // Try first maybe with FAST flag then try again without FAST flag if that fails.
    // Exits loop via break on no error of got exit on error
    // The sp<> references will be dropped when re-entering scope.
    // The lack of indentation is deliberate, to reduce code churn and ease merges.
    for (;;) {
    // release previously opened input if retrying.
    if (output.inputId != AUDIO_IO_HANDLE_NONE) {
        recordTrack.clear();
        AudioSystem::releaseInput(portId);
        output.inputId = AUDIO_IO_HANDLE_NONE;
        output.selectedDeviceId = input.selectedDeviceId;
        portId = AUDIO_PORT_HANDLE_NONE;
    }
    lStatus = AudioSystem::getInputForAttr(&input.attr, &output.inputId,
                                      input.riid,
                                      sessionId,
                                    // FIXME compare to AudioTrack
                                      adjAttributionSource,
                                      &input.config,
                                      output.flags, &output.selectedDeviceId, &portId);
    if (lStatus != NO_ERROR) {
        ALOGE("createRecord() getInputForAttr return error %d", lStatus);
        goto Exit;
    }


    {
        Mutex::Autolock _l(mLock);
        RecordThread *thread = checkRecordThread_l(output.inputId); 
        if (thread == NULL) {
            ALOGW("createRecord() checkRecordThread_l failed, input handle %d", output.inputId);
            lStatus = FAILED_TRANSACTION;
            goto Exit;
        }


        ALOGV("createRecord() lSessionId: %d input %d", sessionId, output.inputId);


        output.sampleRate = input.config.sample_rate;
        output.frameCount = input.frameCount;
        output.notificationFrameCount = input.notificationFrameCount;


        recordTrack = thread->createRecordTrack_l(client, input.attr, &output.sampleRate, //创建recordTrack 
                                                  input.config.format, input.config.channel_mask,
                                                  &output.frameCount, sessionId,
                                                  &output.notificationFrameCount,
                                                  callingPid, adjAttributionSource, &output.flags,
                                                  input.clientInfo.clientTid,
                                                  &lStatus, portId, input.maxSharedAudioHistoryMs);
        LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));


        // lStatus == BAD_TYPE means FAST flag was rejected: request a new input from
        // audio policy manager without FAST constraint
        if (lStatus == BAD_TYPE) {
            continue;
        }


        if (lStatus != NO_ERROR) {
            goto Exit;
        }


        if (recordTrack->isFastTrack()) {
            output.serverConfig = {
                    thread->sampleRate(),
                    thread->channelMask(),
                    thread->format()
            };
        } else {
            output.serverConfig = {
                    recordTrack->sampleRate(),
                    recordTrack->channelMask(),
                    recordTrack->format()
            };
        }


        // Check if one effect chain was awaiting for an AudioRecord to be created on this
        // session and move it to this thread.
        sp<EffectChain> chain = getOrphanEffectChain_l(sessionId);
        if (chain != 0) {
            Mutex::Autolock _l(thread->mLock);
            thread->addEffectChain_l(chain);
        }
        break;
    }
    // End of retry loop.
    // The lack of indentation is deliberate, to reduce code churn and ease merges.
    }


    output.cblk = recordTrack->getCblk();
    output.buffers = recordTrack->getBuffers();
    output.portId = portId;


    output.audioRecord = new RecordHandle(recordTrack); //创建RecordHandle
    _output = VALUE_OR_FATAL(output.toAidl());


Exit:
    if (lStatus != NO_ERROR) {
        // remove local strong reference to Client before deleting the RecordTrack so that the
        // Client destructor is called by the TrackBase destructor with mClientLock held
        // Don't hold mClientLock when releasing the reference on the track as the
        // destructor will acquire it.
        {
            Mutex::Autolock _cl(mClientLock);
            client.clear();
        }
        recordTrack.clear();
        if (output.inputId != AUDIO_IO_HANDLE_NONE) {
            AudioSystem::releaseInput(portId);
        }
    }


    return lStatus;
}

以上函数有三个关键步骤：

  • 调用AudioSystem::getInputForAttr函数获取到匹配的输入设备。

  • 调用recordTrack = thread->createRecordTrack_l函数创建RecordTrack。

  • 调用new RecordHandle创建TrackHandle。

下面分别进行分析：

AudioSystem getInputForAttr

调用AudioSystem::getInputForAttr函数获取到匹配的输入设备：

//frameworks/av/media/libaudioclient/AudioSystem.cpp
status_t AudioSystem::getInputForAttr(const audio_attributes_t* attr,
                                      audio_io_handle_t* input,
                                      audio_unique_id_t riid,
                                      audio_session_t session,
                                      const AttributionSourceState &attributionSource,
                                      const audio_config_base_t* config,
                                      audio_input_flags_t flags,
                                      audio_port_handle_t* selectedDeviceId,
                                      audio_port_handle_t* portId) {
    if (attr == NULL) {
        ALOGE("getInputForAttr NULL attr - shouldn't happen");
        return BAD_VALUE;
    }
    if (input == NULL) {
        ALOGE("getInputForAttr NULL input - shouldn't happen");
        return BAD_VALUE;
    }
    if (selectedDeviceId == NULL) {
        ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
        return BAD_VALUE;
    }
    if (portId == NULL) {
        ALOGE("getInputForAttr NULL portId - shouldn't happen");
        return BAD_VALUE;
    }


    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); //取得IAudioPolicyService接口
    if (aps == 0) return NO_INIT;


    media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
            legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));
    int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(*input));
    int32_t riidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(riid));
    int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
    AudioConfigBase configAidl = VALUE_OR_RETURN_STATUS(
            legacy2aidl_audio_config_base_t_AudioConfigBase(*config, true /*isInput*/));
    int32_t flagsAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
    int32_t selectedDeviceIdAidl = VALUE_OR_RETURN_STATUS(
            legacy2aidl_audio_port_handle_t_int32_t(*selectedDeviceId));


    media::GetInputForAttrResponse response;


    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
            aps->getInputForAttr(attrAidl, inputAidl, riidAidl, sessionAidl, attributionSource, //调用IAudioPolicyService的getInputForAttr函数
                configAidl, flagsAidl, selectedDeviceIdAidl, &response)));


    *input = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(response.input));
    *selectedDeviceId = VALUE_OR_RETURN_STATUS(
            aidl2legacy_int32_t_audio_port_handle_t(response.selectedDeviceId));
    *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(response.portId));


    return OK;
}

AudioPolicyService getInputForAttr

AudioSystem的getInputForAttr函数会调用到AudioPolicyService的getInputForAttr函数：

//frameworks/av/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
Status AudioPolicyService::getInputForAttr(const media::AudioAttributesInternal& attrAidl,
                                           int32_t inputAidl,
                                           int32_t riidAidl,
                                           int32_t sessionAidl,
                                           const AttributionSourceState& attributionSource,
                                           const AudioConfigBase& configAidl,
                                           int32_t flagsAidl,
                                           int32_t selectedDeviceIdAidl,
                                           media::GetInputForAttrResponse* _aidl_return) {
    audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
            aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
    audio_io_handle_t input = VALUE_OR_RETURN_BINDER_STATUS(
            aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
    audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
            aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
    audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
            aidl2legacy_int32_t_audio_session_t(sessionAidl));
    audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
            aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl, true /*isInput*/));
    audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
最低0.47元/天 解锁文章
Android Framework 音频子系统（17）AudioRecord框架
zjy764219923的专栏
09-30 1818
AudioRecord框架
Android Audio基础——AudioFlinger介绍（五）
小旭的专栏
05-11 1297
IAudioFlinger.cpp 是 AudioFlinger 给上层提供的接口。AudioFlinger 服务启动后，其他进程可以通过 ServiceManager 来获取其代理对象 IAudioFlinger，通过 IAudioFlinger 可以向 AudioFlinger 发出各种服务请求，从而完成自己的音频业务。源码位置：/frameworks/av/media/libaudioclient/IAudioFlinger.cpp// 创建Track// 创建Record。
Android 5.1 Audio系统笔记：AudioRecord
biandan1231的专栏
10-02 826
AudioRecord前言AudioTrack第一部分：AudioRecord创建8.1 native_setup8.1.4 set8.1.4.4 创建IAudioRecord对象 openRecord_l8.1.4.4.3 getInputForAttr8.1.4.4.3.1 AudioPolicyService::getInputForAttr8.1.4.4.3.1.2 AudioPolicyManager::getInputForAttr8.1.4.4.3.1.2.1.调用getDeviceAndMi
AudioRecord一个设备只创建一个线程
qq_25260079的博客
04-14 923
不要太相信方法名，尤其是那种看起来很简单的方法名。 在很多博客下面都已经讲过AudioRecord的创建流程，从android_media_AudioRecord.cpp--->AudioRecord--->AudidPolicyService--->AudioPolicyManager--->AudioFlinger 其中过程就不细讲，其中最关键的方法就是getInputForAttr() 前面的调用不提，最终会调用到AudioPolicyManager.cpp的getInp
Android12 Native C++ 层AudioRecord录音AudioTrack播放
crl6的博客
04-10 5071
一、背景： 发现网上能搜到的都是几年前的例子，现在Android版本都出到12了，几年前的例子以及不适用新版本了。于是就自己研究了下AudioRecord.java是如何调用到jni和C++层的AudioRecord.cpp。做一下记录为后来者避坑（PS:以前都不喜欢写博客，本人没时间也不太想分享）。改demo应该适用于Android8，Android9，Android10，Android11，Android12。或许过个几年到Androidxx又不适用了。 二、遇到比较有意思的坑： 程序...
Android13音频子系统分析(三)---音效算法集成框架
余静江的博客
10-13 8980
Android的音效架构中，将所有的音效算法全部挂载到AudioHAL进程中运行。根据音效算法应用的位置，可以分为三类：Track音效、Stream音效、Device音效。即：针对某一个Track的处理音效、针对某种StreamType的处理音效、针对某个Device的处理音效。在中我们已经看到，Track只是在APP层和AudioServer框架层中的概念，到了AudioHAL层已经没有Track的概念，只有Stream和Device。
Android13音频子系统分析(一)---整体架构
余静江的博客
09-14 1万+
本文基于AOSP13源码进行分析解读。所以与各个SoC平台厂商提供的运行在真实设备上的源码会有细微差异，但核心原理区别不大。音频子系统在Android中是一个较为复杂的子系统，横跨应用API层，框架层，Native层和HAL层。使用Java、C++、C语言进行编写。运行在Linux用户空间的4个进程中：APP应用进程(API层的代码)、SystemServer进程(框架层的代码)、AudioServer进程(Native层的代码)、AudioHAL进程(HAL层的代码)。
Android13 CreateRecord流程分析
liuning1985622的博客
05-07 468
进行AudioRecord相关操作前需要先创建一个Record，如下为CreateRecord的流程：首先在AudioRecord的构造函数中会调用native_setup方法： 通过查询JNI代码android_media_AudioRecord.cpp得出调用的函数是android_media_AudioRecord_setup： 在android_media_AudioRecord_setup中创建AudioRecord并调用AudioRecord的set函数： 这个函数会创建并运行Aud
Android 音频源码分析——AudioFlinger
奋斗的菜鸟ing
04-07 2842
Android 音频源码分析——AndroidRecord录音（一） Android 音频源码分析——AndroidRecord录音（二） Android 音频源码分析——AndroidRecord音频数据传输流程 Android 音频源码分析——audioserver启动 Android 音频源码分析——AudioFlinger 混音：把多种来源的声音，整合至一个立体音轨或单音轨中。 AudioFlinger和AudioPolicyService是音频中的两大服务，这里先整理下AudioFlinger。
Android音频管理：AudioFlinger分析
热门推荐
u013490411的博客
08-17 1万+
1.Android音频框架概述 Audio是Android平台非常重要的一个组成部分，负责音频数据的输出采集，音频流的控制，音量调节，音频设备的管理等。我们先来简单介绍一下播放一首音乐的流程：首先应用层点击播放音乐的时候应用会通过mediaplayer接口去启动Android系统的播放器NuPlayer。其实mp3或者flac等格式的音频文件就是一个特殊的压缩文件，所以播放一个音频文件首先要做的就是要去解压缩，Nuplayer通过mediaextractor（高通的有自己的解封装模块mmparser）去解封
Android13音频子系统分析-整体架构
不定时记录分享一些有用没用的东西
06-26 1471
目录 一、应用API层 二、Java框架层 三、Native核心层 3.1 AudioFlinger模块 3.2 AudioPolicyService模块 四、HAL层 本文基于AOSP13源码进行分析解读。所以与各个SoC平台厂商提供的运行在真实设备上的源码会有细微差异，但核心原理区别不大。 音频子系统在Android中是一个较为复杂的子系统，横跨应用API层，框架层，Native层和HAL层。使用Java、C++、C语言进行编写。运行在Linux用户空间的
Audio-AudioRecord create(一)
Cmatrix204的博客
06-29 1414
AudioRecord create相关代码流程、重点关键接口、参数解析以及相关log share分析比对。参数解析：audioSource: MediaRecorder.AudioSource.MIC，详细定义需check MediaRecorder.AudioSource;sampleRateInHz：默认采样率，单位Hz，44100Hz是唯一能保证在所有设备上工作的采样率；channelConfig： 描述音频通道设置，AudioFormat.CHANNEL_CONFIGURATION_MONO保证能
Android 音频开发
特立独行的博客
08-03 3239
Android音频开发在移动应用和娱乐领域有着广阔的前景。随着智能手机的普及和性能的提升，人们对音频功能和体验的需求也越来越高。
AudiFlinger和AudioRecord简述
03-12 4815
Android Audio Android是架构分为三层： 底层      Linux Kernel 中间层  主要由C++实现 （Android 60%源码都是C++实现） 应用层  主要由JAVA开发的应用程序 应用程序执行过程大致如下: JAVA应用程序产生操作（播放音乐或停止），然后通过JNI调用进入中间层执行C++代码，中间层处理后可能需要硬件产生动作的，会继续将操作传
Unity SDK对接全攻略之Android
01-11
本课程带大家学习Unity和Android交互相关的知识，如果你是刚接触Android，或刚接到对接SDK的任务，那么这堂课程你一定不要错过，带你从零到对接一款SDK的全流程。课程包括五个大的部分，从环境配置到发布、到发布第一款APK，除了Unity内置的一些相关的跨平台的知识，还会带你飞速熟悉Android开发，讲解完Unity和Android交互还会带你接一款讯飞语音识别的SDK。
android studio (record audio)一些问题记录
qq_45730855的博客
03-29 4109
as
【无标题】
m0_37833227的博客
09-12 916
E/IAudioFlinger: createRecord returned error -1
通过AudioRecord过程详解Android Audio系统
u012759483的专栏
11-12 3934
从Android API AudioRecorder构造过程开始： 构造函数调用了native_setup native函数，在android_media_AudioRecorder.cpp jni文件中，基本的API接口都对应了native接口。 private native final int native_setup(Object audiorecord_this, Object /*AudioAttributes*/ attributes, .
Android警告错误搜集
killcwd的专栏
05-24 2672
 Eclipse提示： 50.overlaps the location of another project: 'xxxx' new -> android project -> create project from exist source 出现如下错误信息： Invalid project description ------>detail: ->>> xxxx(projec
AudioRecord和AudioFlinger之间数据的交互过程
最新发布
07-18
<think>我们正在讨论AudioRecord与AudioFlinger之间的音频数据交互流程。根据Android音频子系统的设计，AudioRecord负责从音频输入设备（如麦克风）采集音频数据，而AudioFlinger作为音频系统的核心服务，负责管理音频流和硬件设备。下面将详细分析两者之间的数据交互过程。 ### 1. **AudioRecord初始化与AudioFlinger建立连接** 当创建AudioRecord对象时，系统会通过一系列调用与AudioFlinger建立连接： - **绑定音频输入源**：根据指定的音频源（如麦克风）找到对应的输入设备。 - **创建Track**：在AudioFlinger中创建一个RecordTrack（或RecordThread）用于管理该音频输入流。 - **共享内存分配**：AudioFlinger会分配一块共享内存（通过内存映射方式）作为音频数据的环形缓冲区（FIFO）。 ```mermaid sequenceDiagram participant AR as AudioRecord participant AF as AudioFlinger AR->>AF: 请求分配输入流 (createRecord) AF-->>AR: 返回共享内存控制块 (audio_record_cblk_t) AF->>AF: 创建RecordThread AR->>AR: 初始化环形缓冲区 ``` ### 2. **音频数据流传输机制** 音频数据通过环形缓冲区进行传输： - **生产者-消费者模型**： - **生产者**：AudioRecord将采集到的音频数据写入环形缓冲区。 - **消费者**：AudioFlinger的RecordThread从缓冲区读取数据并处理（如重采样、混音等）。 - **同步控制**：通过`audio_record_cblk_t`控制块实现同步（如读写位置指针、锁机制）[^3][^4]。 ### 3. **关键数据结构** - **环形缓冲区 (FIFO)**： - 由共享内存实现，通过`audio_record_cblk_t`管理[^3]。 - 包含读写指针、数据帧计数等元数据。 - **控制块 (audio_record_cblk_t)**： - 原子变量：读写位置索引（避免锁竞争）。 - 条件变量：通知数据可用性（如缓冲区满/空时的等待/唤醒）[^4]。 ### 4. **数据读写流程** #### **AudioRecord写入数据** ```java // 伪代码：AudioRecord.read() 内部流程 1. 检查缓冲区可写空间 2. 将麦克风采集的数据拷贝到环形缓冲区 3. 更新写指针 4. 通知AudioFlinger有新的数据可用 ``` #### **AudioFlinger读取数据** ```cpp // 伪代码：RecordThread::threadLoop() while (true) { 1. 等待缓冲区有足够数据（条件变量触发） 2. 从环形缓冲区读取数据 3. 执行音频处理（如重采样、格式转换） 4. 将数据传递给上层应用或保存到文件 5. 更新读指针 } ``` ### 5. **异常处理机制** - **缓冲区欠载**：当AudioFlinger读取速度超过写入速度时，返回错误码`ERROR_INVALID_OPERATION`。 - **权限问题**：未获取`RECORD_AUDIO`权限会导致初始化失败。 - **资源竞争**：多路录音时，硬件资源不足会触发`ERROR_DEAD_OBJECT`。 ### 6. **完整交互流程图** ```mermaid graph TD A[AudioRecord初始化] --> B[绑定AudioFlinger] B --> C[创建RecordTrack] C --> D[分配共享内存缓冲区] D --> E[启动录音线程] E --> F[持续写入音频数据] F --> G[AudioFlinger读取数据] G --> H[音频处理] H --> I[输出到目标] ``` ### 7. **性能优化点** - **缓冲区大小**：根据`getMinBufferSize()`动态调整，避免频繁线程切换。 - **内存对齐**：共享内存按缓存行对齐（64字节）减少竞争。 - **低延迟模式**：Android 10+支持`AUDIO_PERFORMANCE_MODE_LOW_LATENCY`[^2]。 > 💡 **设计要点**： > AudioRecord与AudioFlinger的交互基于**零拷贝原则**——数据直接在共享内存中传递，无需跨进程复制[^4]。这显著降低了音频采集的延迟。 --- §§相关问题§§ 1. AudioRecord的环形缓冲区如何避免读写冲突？ 2. Android低延迟音频采集的实现原理是什么？ 3. 多路录音时AudioFlinger如何管理多个AudioRecord？ 4. AudioRecord采集的音频数据如何传递给MediaCodec编码？</think>### Android AudioRecord与AudioFlinger音频数据交互流程详解 #### 1. **初始化阶段建立连接** 当创建`AudioRecord`实例时，会通过Binder机制与`AudioFlinger`服务建立连接： ```mermaid sequenceDiagram participant AR as AudioRecord participant AF as AudioFlinger AR->>AF: createRecord() 请求 AF->>AF: 根据音频源选择输入设备 AF->>AF: 创建RecordThread线程 AF-->>AR: 返回IAudioRecord接口 AR->>AR: 通过IAudioTrack获取共享内存控制块 ``` - **关键步骤**： 1. `AudioRecord`调用`createRecord()`请求连接 2. `AudioFlinger`根据音频源（如麦克风）选择硬件设备 3. 创建专用的`RecordThread`处理音频流 4. 返回`IAudioRecord`接口用于后续控制[^2][^4] #### 2. **共享内存缓冲区设计** 音频数据通过**环形缓冲区(FIFO)** 实现零拷贝传输： ```mermaid graph LR A[麦克风硬件] --> B(AudioRecord) B --> C[环形缓冲区] C --> D(RecordThread) D --> E[AudioFlinger] ``` - **核心组件**： - `audio_record_cblk_t`：共享内存控制块 - 包含读写指针、帧计数等元数据 - 使用原子操作保证线程安全 - 数据缓冲区：PCM音频数据存储区 - 同步机制：条件变量实现读写同步[^3][^4] #### 3. **数据流传输过程 ##### AudioRecord侧（生产者）： ```java // 伪代码：数据写入流程 void AudioRecord::read() { // 1. 等待缓冲区可写空间 waitForFreeSpace(); // 2. 从音频驱动读取数据 size_t framesRead = audioHwDev->read(); // 3. 数据写入环形缓冲区 memcpy(sharedBuffer + writePos, pcmData, dataSize); // 4. 更新写指针 atomic_add(&cblk->framesWritten, framesRead); // 5. 唤醒消费者 signalDataAvailable(); } ``` ##### AudioFlinger侧（消费者）： ```cpp // RecordThread线程循环 void RecordThread::threadLoop() { while(!exitPending()) { // 1. 等待数据可用 waitForDataAvailable(); // 2. 计算可读帧数 framesToRead = cblk->framesAvailable(); // 3. 从缓冲区读取数据 memcpy(processBuffer, sharedBuffer + readPos, dataSize); // 4. 更新读指针 atomic_add(&cblk->framesRead, framesToRead); // 5. 音频处理（重采样/格式转换） processAudio(processBuffer); // 6. 分发到目标应用 deliverToClient(); } } ``` #### 4. **同步控制机制** - **缓冲区状态管理**： - 写阻塞：当`framesWritten - framesRead == bufferSize`时，生产者等待 - 读阻塞：当`framesWritten == framesRead`时，消费者等待 - **优先级控制**： - `RecordThread`运行在`PRIORITY_URGENT_AUDIO`优先级 - 确保实时性要求[^1][^4] #### 5. **异常处理场景** | 错误场景 | 触发条件 | 处理机制 | |---------|---------|---------| | 缓冲区溢出 | 写入速度 > 读取速度 | 丢弃新数据，返回`WOULD_BLOCK` | | 设备丢失 | 耳机拔出/麦克风禁用 | 回调`onError(ERROR_DEAD_OBJECT)` | | 权限失效 | RECORD_AUDIO权限撤销 | 终止流，抛出`SecurityException` | #### 6. **性能优化设计** 1. **内存对齐**： ```cpp // 缓冲区按cache line对齐（通常64字节） posix_memalign(&buffer, 64, bufferSize); ``` 2. **批处理优化**： - 每次读写至少处理`minFrameCount`帧（约10ms数据） 3. **直接传输路径**： - 支持`AudioRecord.obtainDirectBuffer()`避免拷贝[^5] > 💡 **关键设计思想**： > 通过**共享内存+控制块**的架构，实现跨进程音频传输的零拷贝，满足实时性要求： > $$ \text{延迟} \propto \frac{\text{缓冲区大小}}{\text{采样率}} $$ > 典型配置：160帧缓冲区 @ 16kHz采样率 → 10ms延迟 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值