夜雨聆风学习资料网

ARTICLE · 1361806

Android源码第十四章:AudioFlinger 与音频系统——一次写入怎样走到声音

Android源码第十四章:AudioFlinger 与音频系统——一次写入怎样走到声音

点「播放 1 秒」,AudioTrack.write() 已经返回正数,扬声器却可能还没响。这个返回值只记录这次交给轨道的采样数。播放头记录轨道消费进度。要确认声音是否真的出来,再看当前路由和实际输出。

文章目录

• 14.1 用 AudioTrack 播放,用 AudioRecord 读取

• 14.2 在 Android Studio 里跑一轮播放和录音

• 14.3 Java AudioTrack 怎样取得 Native 客户端

• 14.4 AudioPolicy 选输出,AudioFlinger 创建轨道

• 14.5 应用发布 PCM,播放线程取数混音

• 14.6 HAL 把混音结果交给 ALSA 和所选后端

• 14.7 AudioRecord 从输入端取回 PCM

• 14.8 看清焦点、路由、播放进度和资源释放

• 14.9 从没声音回查到各层

• 附录 A|完整示例

• 附录 B|诊断音频会话和设备后端

• 参考资料

14.1 用 AudioTrack 播放,用 AudioRecord 读取

应用已经拿到 PCM 时,可以用 AudioTrack 播放。要从麦克风等输入端读取 PCM,则使用 AudioRecord,并先声明和申请 RECORD_AUDIO。两种 API 都由应用创建客户端对象,系统服务负责建立轨道、选择设备和交接数据。播放焦点由 AudioManager 单独请求,允许申请焦点的条件随系统版本和 targetSdk 变化。

PCM 是未压缩的采样值序列。一帧包含同一时刻的全部声道。本例播放 48 kHz、单声道、PCM 16 bit 的一秒正弦波,48000 帧就是 48000 个 short、96000 字节。双声道的一秒仍是 48000 帧,每帧两个采样,共 96000 个 short。Java short[] 的 write/read 返回 short 数,Native write 常以字节计,HAL 通常用帧表示传输进度。

在工作线程运行下面的播放主路径。完整示例还会检查最小容量、轨道状态和焦点,并在同一线程清理对象。

AudioTrack track = new AudioTrack.Builder()        .setAudioAttributes(attributes)        .setAudioFormat(playbackFormat)        .setTransferMode(AudioTrack.MODE_STREAM)        .setBufferSizeInBytes(bufferBytes)        .build();track.play();int written = track.write(pcm, offset, requested, AudioTrack.WRITE_NON_BLOCKING);

按 written 的实际正数推进偏移。 一次短写后继续提交剩余采样,返回零则稍后重试,负数按错误处理。把读写放在 worker,给循环加退出条件,页面按键仍可响应。播放完整时调用 stop(),取消或超时时对活动轨道调用 pause()、flush(),最后释放对象和焦点。

录音先确认麦克风权限,再在 worker 使用已初始化的 AudioRecord。附录中的 Builder 选用 MIC 音源。

record.startRecording();int count = record.read(chunk, 0, chunk.length, AudioRecord.READ_NON_BLOCKING);

正数是这次读到的采样数,零表示暂时无数据,负数表示错误。示例只统计帧数和峰值,结束时停止并释放 AudioRecord。

buffer 暂存采样。容量除以采样率能换算成一段名义时长。真实出声还受排队、混音、设备和宿主输出影响。播放端缺采样称为 underrun,录音消费者赶不上生产速度时可能发生 overrun 并丢掉旧采样。

14.2 在 Android Studio 里跑一轮播放和录音

1. 在 Android Studio 新建 Empty Views Activity 项目。选 Java,包名使用 com.example.audiochapter,Minimum SDK 26。保留模板的 Gradle 文件,使用已安装且 API 35 或更高的 compileSdk。按附录 A覆盖两个文件,完成 Gradle 同步。

2. 在 Device Manager 创建 Phone AVD,例如 Pixel 配置加 Android 14(API 34)Google APIs 镜像,选适合电脑架构的系统镜像。选中 AVD 点 Run。打开媒体音量,在 Android Studio 的 Logcat 中用 package:com.example.audiochapter tag:AudioChapter 过滤。

3. 保持页面前台,先点「播放1秒」。听到短音时记下实际输出设备,再看同一 run= 的日志。录音第一次点击若弹权限框,允许使用麦克风后再点一次。已经授权时直接点击即可。录音只统计峰值和帧数。

4. 需要让 AVD 录到宿主的声音时,在 Extended Controls 的 Microphone 页打开 Enable Host Microphone Access。有些版本显示 Virtual microphone uses host audio input,宿主系统也可能要求授权。用自己的声音做一次短测试。可保持声源不变,比较宿主麦克风访问关闭和开启时的 frames、peak 与路由。没有声音输入的 AVD 仍可能交回足量静音帧。

观察
可以判断什么
FOCUS result=1
此次焦点请求获准。
PLAY end
 的 submitted=48000、head 达到 48000 且 complete=true
这一轮提交完整,轨道播放头达到示例的目标。是否实际听见,另看路由、媒体音量和宿主输出。
RECORD end
 的 frames=24000、complete=true
应用读取到半秒的名义帧量。结合已知声源、peak 和路由判断是否取得有效输入。
FAIL
、complete=false 或缺少本轮 end
按同一个 run= 查焦点、初始化、权限、超时或取消。
WORKER_END
worker 到达本轮收尾日志。清理期间若有异常,还需结合 FAIL 判断。

提交和等待播放头共用四秒的循环截止时间。该时间用于结束应用的观察和重试,系统调用耗时依然由当时的设备和服务决定。示例每轮用独立的取消标记。焦点变化、取消按钮和离开页面都能请求该轮退出,实际停止与释放在 worker 中处理。

先看三张总图

架构图定位应用进程、system_server、audioserver、Audio HAL 和设备后端。策略决定输出,播放和录音的 I/O 线程负责连续交接采样。应用与 audioserver 之间的共享内存、HAL 的 FMQ(快速消息队列),是两段不同的通道。创建轨道时取得控制块 cblk 和采样区的描述。控制块记录读写位置和状态,采样值存放在 PCM 区。

流程图从前台的播放按钮开始,沿焦点、创建、写入、混音、HAL 及收尾定位失败。录音的 PCM 方向反过来,14.7 会从设备一路讲回 App。

时序总图把播放、取消和录音放在同一组参与者下。它以普通 PCM 流和可读的 AIDL HAL 分支为例。HAL、ALSA 与 VirtIO 后端须按目标运行配置核对,普通 AVD 的日志只能说明本次实际观察到的应用行为。

14.3 Java AudioTrack 怎样取得 Native 客户端

AudioTrack.Builder 组织 AudioAttributes、AudioFormat、buffer 字节数与 MODE_STREAM;build 进入 AudioTrack 构造,构造调用 native_setup。JNI 注册表把这一 Native 方法绑定到 android_media_AudioTrack_setup。JNI 是同一应用线程中的语言边界,本身不创建“JNI 线程”。

本节来源:frameworks/base 固定提交 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d,core/jni/android_media_AudioTrack.cpp 的 setup,MODE_STREAM 分支。以下是该分支的连续摘录:

bool useMmapAsBackend = false;if (audio_is_linear_pcm(format) && offload) {    if (AudioSystem::useMmapForPcmOffload(&useMmapAsBackend) != NO_ERROR) {        ALOGD("Failed to query useMmapForPcmOffload, will use classical offload");        useMmapAsBackend = false;    }    ALOGD("Use aaudio mmap as backend for PCM offload: %d", useMmapAsBackend);}

这里的 mmap 查询有 linear_pcm && offload 条件。 本例不请求 offload,因此继续创建普通 AudioTrack,不能把所有 PCM 流都画进 AudioTrackMmap。JNI 组装 SetParams,普通分支 .sharedBuffer=nullptr、.transferType=TRANSFER_SYNC;Native 构造 AudioTrack(SetParams&&) 调用 set,再创建服务端轨道。SYNC 指客户端同步 write 数据接口,不表示示例必须使用 WRITE_BLOCKING。

setup 后检查 initCheck(),失败返回设置错误;成功把会话 ID、实际采样率写回 Java 的数组参数。再用 setFieldSp 把 Native AudioTrack 强引用保存到 Java mNativeTrackInJavaObj 对应字段,把 JNI 弱引用/回调存储保存在 jniData。后续 getAudioTrack 从同一 Java 实例取出强引用;字段不是跨进程地址,也不是 PCM 数据地址。

本例没有设置 marker/周期通知。若使用它们,Native AudioTrackThread 检查共享位置,再经 JNIAudioTrackCallback 的 postEventFromNative 投递到 Java Handler,由配置的 Looper 执行监听器;回调不会自动回到原 write 的 worker。焦点监听器则走另一条 AudioManager/AudioService 通道,14.8 再看。

14.4 AudioPolicy 选输出,AudioFlinger 创建轨道

策略可以复用已开的输出,需要新输出时才继续开流。

创建和数据写入的完整顺序见 14.2 的全章时序。这里先跟创建请求走到策略和轨道。

Native 创建请求怎样交给服务

来源:frameworks/av 475269ec44acec82792be6b01fb8e16357d4d2c8,media/libaudioclient/AudioTrack.cpp 的 createTrack_l()。它经 AudioSystem::get_audio_flinger() 取得并缓存服务接口,将属性、config(采样率/格式/声道)、flags、帧容量、sessionId、selectedDeviceId、回调与调用者身份封装到 CreateTrackInput,转换为 AIDL 请求。

status = audioFlinger->createTrack(aidlInput.value(), response);

返回先经过 status 与 outputId 检查,再保存服务返回的实际参数。 请求 48000 Hz 不等于硬件必用 48000 Hz;普通 Mixer 可重采样,协商参数与 AF 输出参数分别返回。创建成功得到 output.audioTrack,随后 getCblk 取得共享区域描述,转换 IMemory 并映射。应用和服务的虚拟地址可以不同,指向同一底层共享区域。

AudioFlinger 为什么要先问策略

同一固定 av 提交,services/audioflinger/AudioFlinger.cpp 的 createTrack。服务入口在 Binder 工作线程上处理请求,先校验 AttributionSource 与 session,然后:

lStatus = AudioSystem::getOutputForAttr(&localAttr, &output.outputId, sessionId, &streamType,                                        adjAttributionSource, &input.config, input.flags,                                        &selectedDeviceIds, &portId, &secondaryOutputs,                                        &isSpatialized, &isBitPerfect);output.selectedDeviceIds = selectedDeviceIds;

属性、可用设备、请求 flags 与配置共同影响选路。USAGE_MEDIA 不等于指定扬声器。AudioSystem 进入 AudioPolicyService 的 getOutputForAttr,转换 AIDL 类型并在策略锁保护的范围调用 mAudioPolicyManager->getOutputForAttr。Manager 先清理无效请求设备 ID,再用 getOutputForAttrInt 结合策略引擎/输出配置选取 output;成功时分配 portId、创建 TrackClientDescriptor、登记到输出描述对象。portId 标记这个策略客户端,outputId 指 AudioFlinger 的 I/O 输出。

AudioFlinger 再用 outputId 找 PlaybackThread,在锁内 registerClient 得到该客户端的分配器,调用线程的 createTrack_l 创建服务端 Track。Track 对象关联 thread、Client、session、portId;不是通过应用指针直接访问 Java 对象。失败时 createTrack 的 Exit 路径释放已登记输出,避免把策略占用永久留住;成功包装 TrackHandle,回到 Native 客户端。

谁分配 cblk 和 PCM 空间

同一 av 提交,Tracks.cpp 的 TrackBase 构造。对普通流且 ALLOC_CBLK、未传静态 buffer 的情况,在计算并检查容量溢出后,把控制块与 PCM 空间一起向 Client 分配器申请:

size_t size = sizeof(audio_track_cblk_t);if (buffer == NULL && alloc == ALLOC_CBLK) {    // check overflow when computing allocation size for streaming tracks.    if (size > SIZE_MAX - bufferSize) {        android_errorWriteLog(0x534e4554, "34749571");        return;    }    size += bufferSize;}

TrackBase 随后构造 cblk,令服务端 mBuffer 指向 cblk 后面的 PCM;Track 创建 AudioTrackServerProxy。客户端映射后,createTrack_l 在普通流分支执行:

mStaticProxy.clear();mProxy = new AudioTrackClientProxy(cblk, buffers, mFrameCount, mFrameSize);

两侧 proxy 各自使用本进程地址,靠共享 cblk 的位置与标志协调。 录音另有只读采样区分配分支;MODE_STATIC 则是应用预先提供共享 buffer,不能照搬上述“cblk 紧邻 PCM”的分配规则。

14.5 应用发布 PCM,播放线程取数混音

应用先用 play() 激活轨道,再提交第一批采样。下面先看共享区怎样交接,随后回看 play() 怎样唤起播放线程。

Java write(short[], offset, size, mode) 校验初始化、数组范围与写入模式,调用 native_write_short。JNI 注册映射到模板 android_media_AudioTrack_writeArray<jshortArray>,取回 Native AudioTrack 和数组元素,调用 writeToTrack。

来源:base 同前,writeToTrack 模板,普通流分支原文:

size_t sizeInBytes = sizeInSamples * sizeof(T);if (track->sharedBuffer() == 0) {    written = track->write(data + offsetInSamples, sizeInBytes, blocking);    // for compatibility with earlier behavior of write(), return 0 in this case    if (written == (ssize_t) WOULD_BLOCK) {        written = 0;    }}

成功时 JNI 再 return written / sizeof(T);错误经 interpretWriteSizeError 转换。因此示例短写循环拿到 short 数。JNI 数组访问可能固定或复制,随后 Native 仍有共享区 memcpy,这里没有端到端零拷贝保证。

Native AudioTrack::write 的关键节点(av 同前,省略循环前校验与后统计):obtainBuffer 请求可用帧,阻塞参数决定等空闲还是立即尝试;拿不到时,已有部分写入就返回部分量,否则映射错误返回。拿到后:

size_t toWrite = audioBuffer.size();memcpy(audioBuffer.raw, buffer, toWrite);buffer = ((const char *) buffer) + toWrite;userSize -= toWrite;written += toWrite;releaseBuffer(&audioBuffer);

先复制 PCM,再 releaseBuffer 发布进度。 如果每个小块都用 Binder 传 PCM,接收端需要对每批采样做跨进程消息处理。当前通道让双方通过共享区批量交接,Binder 留给创建和控制。代价是双方必须约定 ring 的位置、发布顺序和等待条件,生产者与消费者也可能一时跟不上对方。

AudioTrack::releaseBuffer 继续调用 ClientProxy;AudioTrackShared.cpp 中输出方向以 release store 增加 mRear,服务端用 acquire 读 mRear 看到可消费量。服务端取数混音后通过 ServerProxy 增加 mFront;客户端 acquire mFront 才知道又有空位。等待路径使用 futex,唤醒只令线程有机会继续运行,不保证立即被调度。

AudioTrack.play() → Java startImpl/native_start → Native start → IAudioTrack::start → TrackHandle::start → Track::start。Track 激活并与策略 startOutput 配合,唤醒对应 PlaybackThread。Binder 入口线程负责改变轨道状态,连续搬运 PCM 的是播放线程。 普通 MixerThread 通过 Track 的 buffer provider 取得数据,AudioMixer 混音/按需重采样、音量与 effect chain 处理,输出 sink buffer。不是应用每 write 一次,AudioFlinger 就同步混一次并回一个“已出声”。

同一 av 提交 Threads.cpp,PlaybackThread::threadLoop_write 有 mNormalSink 与直接 mOutput 两条实现选择。普通输出最终借助 AudioStreamOutSink/Output/StreamOutHalInterface 到 HAL write;如果启用 FastMixer,普通混音结果可先交给 MonoPipe,由 FastMixer 统一送 HAL。mNormalSink 分支返回帧并换算字节;mOutput 分支直接写剩余字节。这些是备选执行路径,不应串成“先正常混音再必经快速轨道”的固定顺序。 本例不请求 FAST,实际线程类型仍需 dumpsys 证实。

14.6 HAL 把混音结果交给 ALSA 和所选后端

应用把采样交到 AudioFlinger 后,混音结果还要经过 HAL 自己的队列。这里从 audioserver 继续向下看。

AIDL 管理与三个队列

frameworks/av 同前,DeviceHalAidl::openOutputStream 在端口、配置和路由映射准备后调用 mModule->openOutputStream(args, &ret),得到 IStreamOut 与 StreamDescriptor,建立 StreamOutHalAidl 及队列上下文。HAL 侧 Module 创建 StreamContext,拥有 command/reply/data 队列;StreamContext::fillDescriptor 复制队列描述供 Framework 映射。描述不是采样本体。

选普通非 MMAP AIDL 流时,StreamDescriptor 包含 command FMQ、reply FMQ 和 audio data FMQ;若选 mmap,audio union 是 mmap 描述,不能再解释为 data FMQ。以下是 av StreamHalAidl::transfer 的普通输出连续摘录:

StreamDescriptor::Command burst =        StreamDescriptor::Command::make<StreamDescriptor::Command::Tag::burst>(bytes);if (!mIsInput) {    if (!mContext.getDataMQ()->write(static_cast<const int8_t*>(buffer), bytes)) {        AUGMENT_LOG(E, "failed to write %zu bytes to data MQ", bytes);        return NOT_ENOUGH_DATA;    }}StreamDescriptor::Reply reply;RETURN_STATUS_IF_ERROR(sendCommand(burst, &reply));*transferred = reply.fmqByteCount;

先把 PCM 字节放入 data MQ,再发 burst 请求并接住回复。 transfer 在 STANDBY 时先发 start,要求回到 IDLE,否则返回错误。sendCommand 利用 command/reply 队列及 event flag 完成握手;reply 的传输量和状态表明 HAL 本轮处理结果,不等于扬声器呈现。

hardware/interfaces 固定提交 0162af698935100a590b7359581ac8b1b80693e5,default/Stream.cpp 的 StreamOutWorkerLogic::write。HAL 的 writer 工作线程先从 data MQ 读出字节到自己的 mDataBuffer,取客户端请求量、队列已有量与本地容量的最小值;连接设备时调用:

if (::android::status_t status = mDriver->transfer(            mDataBuffer.get(), byteCount / frameSize, &actualFrameCount, &latency);    status != ::android::OK) {    fatal = true;    LOG(ERROR) << __func__ << ": write failed: " << status;}

这里 mDriver 是实现流对象提供的驱动接口,不是 Kernel 指针。若 transfer 失败,write 返回 false,调用方 cycle 将流置为 ERROR,并把该状态写入 reply.state;局部 fatal 布尔值不是进程 abort。populateReply 还会填写状态字段,不能把每次 transfer 错误都简化成当轮同步负返回。成功后把 actualFrameCount 换算字节,填 reply 的 fmqByteCount、状态、位置和 latency;未连接分支可以模拟消耗。因此即使收到了正传输量,仍要核对路由、stub 与后端。

primary 用 MonoPipe 交给独立 I/O 线程

同一 interfaces 提交的 default/primary/StreamPrimary.cpp 可选真实 ALSA 或 stub:设备为空、特定设备类型、simulate_input/ignore_output 属性等可令其模拟输入/输出。设备地址能解析 CARD_x_DEV_y;否则使用实现默认卡/设备,不在教程中把固定 card0 当所有产品的事实。

选择非 stub 后,StreamPrimary::start 进入 StreamAlsaMonoPipe::start。后者 openDeviceProxies,依据配置创建本进程 MonoPipe 与 reader,拉起 out_0 或 in_0 I/O 线程。Framework 的 burst 被 HAL worker 接住后,输出 transfer 把采样写入 MonoPipe;独立 outputIoThread 从 pipe 读出,再调 system/media 的 proxy_write_with_retries,继续 tinyalsa pcm_write。

HAL worker 接收与 ALSA I/O 线程是两个执行者。 StreamPrimary 对同步流维护节拍,模拟器补偿分支落后时可跳过下一次传输。参考实现的 StreamAlsaMonoPipe::transfer() 在输入不足时补零,输出写不全时可丢帧,随后仍按请求帧数设置 actualFrameCount。这解释了为什么 HAL 回复的帧数、App 读满及有效声音要分别观察。

打开阶段:StreamAlsaBase::openDeviceProxies 选择设备 profile、协商格式、构造代理并 proxy_open;system/media alsa_device_proxy.c 的 proxy_open 再调用 pcm_open。tinyalsa 的 pcm_hw.c 根据 card/device/direction 打开 /dev/snd/pcmC%uD%u%c,尾字母 p 是 playback,c 是 capture,并通过 ioctl 配置参数与准备流。应用一般不会自己打开声卡节点,HAL 才是这里的持有者。

来源:external/tinyalsa 固定提交 b6d92da6ee7890ce6b5bd9069937283fcc48812a,pcm.c 的 pcm_write,初次准备分支:

if (!pcm->running) {    int prepare_error = pcm_prepare(pcm);    if (prepare_error)        return prepare_error;    if (pcm->ops->ioctl(pcm->data, SNDRV_PCM_IOCTL_WRITEI_FRAMES, &x))        return oops(pcm, errno, "cannot write initial data");    pcm->running = true;    return 0;}

x.frames 是字节数除以声道数和每采样字节数得到的帧数。 这里走 interleaved ioctl 写入;不能因为 tinyalsa 支持 mmap,就说本例使用了 PCM_MMAP。后续 EPIPE 分支可能重启,具体是否返回错误还看 PCM_NORESTART 等条件;系统内部重试也不把应用截止时间变成驱动硬超时。

ALSA 怎样把采样交给 VirtIO 驱动

这一段以 kernel/common 的 ccafb60de224d35a8bc14de33e1cd47caaaa786b 为固定基线。该版本的消息实现位于 virtio_pcm_msg.c。读者在 AVD 中运行 App 后,仍需另外确认活动音频路径是否使用 VirtIO sound。

pcm_native.c 的 snd_pcm_xferi_frames_ioctl 读取用户 xferi,按播放/采集调用 snd_pcm_lib_write/read。pcm_lib.c 的公共传输循环检查状态、可用帧与等待条件,复制用户采样并更新 application pointer;驱动通过 snd_pcm_ops 提供 prepare、trigger、pointer、ack 等实现。对于所选 VirtIO 分支:

rc = snd_pcm_indirect_playback_transfer(substream, &vss->pcm_indirect,                                      virtsnd_pcm_trans_copy);

这是 virtio_pcm_ops.c 的播放 ack 内部连续调用。virtsnd_pcm_trans_copy 进一步 virtsnd_pcm_msg_send(vss, rec->sw_data, bytes);virtio_pcm_msg.c 把流 ID、数据与状态 scatter-gather 描述放进 TX/RX virtqueue。Host 使用描述符,不是拿着应用虚拟地址解引用。used buffer 返回后,驱动按本版本完成逻辑推进 hw_ptr、更新 delay 并按需安排 period 通知;播放方向在此按 msg->length 无条件推进位置,没有按返回 status 成功码校验。因此位置推进仍不能证明实际声音呈现。

看动图里混音结果经过 FMQ、HAL 进程内的 MonoPipe 和独立 I/O 线程,再写给 ALSA。

Cuttlefish 是可读的 Host 路径对照:device/google/cuttlefish 283645aacf6cdb56cc31a9362f54d412dbc132a1 的 crosvm_manager 在 enable_audio 条件下传 --sound=audio_server_path。external/crosvm c7dd8d6950912fa5e6fde7ec2d1616e0ddc090f8 的 vios_backend/streams.rs 从队列取描述,播放调用 inject_audio_data、录音调用 request_audio_data,写回 VirtIO 状态。shm_vios.rs 用共享区域和 socket 协议等待 audio server 回复。

Cuttlefish WebRTC AudioHandler::OnPlaybackBuffer 核对 stream_id 与 active,将 PCM 交 AudioMixer::OnPlayback,再 SendStatus。AudioMixer 可以重采样/混音,经 WebRTC AudioSink 交浏览器。本条可读链在浏览器音频端点止住;浏览器选择的 Host 扬声器、操作系统后端与物理 Codec/DMA 本轮没有运行证据。 它不是必经手机 DSP 的路径;物理设备可用 ALSA/ASoC、Codec、DSP、DMA 等不同实现,需要另配驱动与固件证据。不能把 ASoC 插进 VirtIO 的必经链。

14.7 AudioRecord 从输入端取回 PCM

录音有独立权限和隐私条件。RECORD_AUDIO 声明加运行时授权只是起点;麦克风隐私开关、并发录音策略、前后台限制、源类型和路由仍可能使创建/启动失败或得到静音。示例只在可见 Activity 中手动启动 MIC,读满半秒的名义帧量后停止,取消或超时也会退出。播放完成不会自动开始录音。

Java AudioRecord.Builder → AudioRecord 构造/native_setup → android_media_AudioRecord_setup。JNI 创建 Native AudioRecord、调用 set,传 source、sample rate、format、channel、buffer size/帧数与身份,成功后用 setFieldSp 保存 mNativeRecorderInJavaObj 和 JNI 回调信息。后续 read 从该实例取回同一 Native 客户端。

av 同前,AudioRecord::createRecord_l 发 audioFlinger->createRecord;AudioFlinger::createRecord 先校验调用身份、格式、声道与 session,经 getInputForAttr 取得 inputId、portId、输入设备,再找 RecordThread,调用 createRecordTrack_l 创建 RecordTrack。createRecord 返回 IAudioRecord、cblk 与采样 buffer 描述;客户端持有 mCblkMemory/mBufferMemory,并建立 AudioRecordClientProxy。普通录音可能把 cblk 与只读采样区分开映射,不能硬画成播放的相邻空间。

startRecording() 通过 JNI/Native AudioRecord::start → IAudioRecord::start → RecordHandle/RecordTrack,策略 startInput 做实际录音资格检查并启动 RecordThread。RecordThread 从 HAL 输入 stream 读取;普通路径经 StreamInHalAidl::read → StreamHalAidl::transfer,发 burst、收回复并从 data MQ 取出采样。HAL reader 先调用 mDriver->transfer 从设备/MonoPipe 取帧,再写入 data MQ。ALSA inputIoThread 用 proxy_read_with_retries → tinyalsa pcm_read → SNDRV_PCM_IOCTL_READI_FRAMES。VirtIO RX 或对应真实驱动提供帧。

RecordThread 可对服务采样率与应用参数做重采样、格式转换并分发到各 RecordTrack;同名“record buffer”不等于所有录音客户端直接共享同一个裸设备 ring。

AudioRecord::read 的普通 PCM 路径,先 obtainBuffer 取得服务已写好的区域,再进行必要格式转换:

if (audio_is_linear_pcm(mFormat)) {    memcpy_by_audio_format(buffer, mFormat, audioBuffer.raw, mServerConfig.format,                        audioBuffer.mSize / mServerSampleSize);} else {    memcpy(buffer, audioBuffer.raw, audioBuffer.mSize);}

随后按 bytesRead 推进应用输出指针,releaseBuffer 归还可写空间;JNI short 数组包装换回采样数再交 Java 调用者。播放是应用增加 rear,录音是应用消费后增加 front;两者“release”释放的是一段 ring 使用权,并不等于销毁 AudioTrack/AudioRecord。

示例 READ_NON_BLOCKING 返回零说明暂时没采样;负错误码退出;全部 24000 帧读取且未取消/超时才记 complete。peak=0 可能是安静、静音、隐私处理或 stub,不单凭它推断麦克风坏了。录音异常亦进入 stop/release 的 finally;权限拒绝发生在创建之前。

14.8 看清焦点、路由、播放进度和资源释放

焦点是播放资格协调,音量是增益,路由是设备选择

AudioManager 的 requestAudioFocus(AudioFocusRequest) 会登记监听器,并经 IAudioService 向 system_server AudioService 请求;MediaFocusControl 协调焦点栈、调用者/系统条件和已有持有者。Android 15 及以上且 targetSdk 35 及以上时,普通应用还受“顶层应用或合适前台服务”等请求资格限制,示例从可见页面启动,焦点失败时直接收尾。得到焦点不保证播放,也不代替 RECORD_AUDIO。

焦点变化由服务向 IAudioFocusDispatcher 反向通知,AudioManager 的事件 Handler 在指定 Looper 上调 OnAudioFocusChangeListener。本例指定主 Looper,负向变化只设置该轮的原子取消标记,worker 下次检查后退出;没有从回调线程同时 release 正在写的对象。finally 用原 AudioFocusRequest abandon;即使请求未获准,也清理这次客户端监听登记,不拿返回值当全部本地资源的所有权证明。

音量可能受应用 track 增益、系统音量曲线、静音、duck、音效与设备端增益共同影响。焦点策略可触发系统淡出或 duck,本例把负向变化统一视为取消,避免继续响;这是示例策略,不要求所有播放器遇到 duck 必须停止。

路由由属性、策略、连接状态与偏好共同决定。setPreferredDevice 是偏好,不是强制成功;getRoutedDevice 应在流活动时观察,空值不能冒充固定扬声器。设备变化经 AudioSystem 的 I/O/端口通知与客户端监听分发;图中路由变化可触发重新配置或 invalidation。若服务死亡或 track invalid,Native 某些路径会尝试重建,Java 仍需处理 ERROR_DEAD_OBJECT 等最终结果,不能无限无条件重试并重复副作用。

分别读取提交量、播放头与状态事件

• write/read 的正数:本次采样交接量。

• PlaybackHeadPosition、AudioTimestamp:播放进度与时间关联,各有有效性、回绕和设备支持条件。本例普通 PCM 的 AudioTrack::getPosition() 走 updateAndGetPosition_l(),使用服务端消费的共享计数。完整 timestamp 还需区分服务和 Kernel 等位置,不能把一个头位置当外部麦克风测得的出声时刻。

• 焦点、marker、周期、路由或 offload StreamEventCallback:不同事件与线程语义;marker 到达不自动 stop/release,offload onPresentationEnded 也不能套给本例普通 PCM。

音视频同步常用共同时间基准、采样帧位置与时间戳做调整;Thread.sleep(1000) 只表示应用等过一秒,不能证明声音呈现完成。buffer 更小通常降低排队预算,也更容易 underrun;FAST、AAudio/MMAP、direct/offload 有额外准入与专用线程/设备条件,不能靠 flag 名字断言真正低延迟。压缩 offload 可把压缩数据交 DSP/专用输出,区别于本例 AudioMixer PCM;PCM offload 在本版本又可能转 AudioTrackMmap,需重新读分支。

正常结束、取消和进程退出

本例等待播放头达到提交量后记录 end。正常完成走 stop()。提前停止时,示例在 worker 里对正在播放的 MODE_STREAM 轨道调用 pause() 再 flush(),丢弃轨道里未播放的数据。已经交给更下游的采样有自己的进度。两条路径最终都调用 release() 并尝试归还该轮焦点,结果可查 FOCUS abandon。Native 客户端停止回调、解绑死亡通知并释放代理和共享内存。

服务端 TrackHandle 最后引用消失时调用 Track::destroy;非活跃轨道可以就地撤销,活跃轨道由播放线程完成后续移除与策略端口释放,不能说 release 一返回服务所有资源立即消失。AudioRecord 的 RecordHandle/RecordTrack 对应停止输入与释放 input 端口。

HAL 输出常被多个轨道复用,单个 track release 不必立刻关闭 HAL stream 或声卡 fd。输出空闲/策略关闭时才会 standby/close;本章 primary 的 standby/shutdown 进入 teardownIo:置 I/O 运行标志 false,输入 pipe shutdown,proxy_stop 中断 PCM,join I/O 线程,最后清代理关闭 PCM 与 pipe。关闭不是“先 free buffer 再等仍在访问它的线程”。

看动图如何从取消标记过渡到 worker 清理,同时保留可能被其他轨道使用的输出流。

应用进程退出后,Binder 引用与死亡通知帮助系统回收轨道/焦点,进程映射由内核回收;这属于故障兜底,不能代替示例 finally。宿主退出和物理设备断连还涉及各自服务恢复策略,本轮没有注入这些故障。

14.9 从没声音回查到各层

如果没听见那一秒短音,先用同一轮的 submitted、head 和 routeId 缩小范围,再按下表回查。

症状
先区分什么
对应入口
Builder/初始化失败
参数、最小容量、格式、设备可用性
Java 参数检查、JNI setup、createTrack/createRecord 状态
焦点失败
页面是否前台、调用资格、现有焦点/系统策略
dumpsys audio、MediaFocusControl
一直返回0或 complete=false
是否激活、客户端空位/数据、取消/截止
Native obtainBuffer、cblk flags/位置、AF 线程状态
提交完整仍无声
路由、音量、stub、HAL丢弃、Host输出
audio_policy、audio_flinger、HAL配置/属性、Host端点
录音全零
权限与隐私、输入路由、并发、虚拟输入
RecordThread/策略、HAL reader、stub分支
underrun 或断续
供数速度、调度、buffer、负载
应用日志 + AF统计 + 有效trace;不能只凭时间邻近归因
release 后还看到输出线程
输出复用/空闲策略与缓存
Track/port是否仍在、HAL流是否共享;不是仅看线程存活

系统侧诊断命令和底层验证条件见附录 B。

回顾与自测

1. 为什么 write=960 不证明声音已经到扬声器?参考:14.5/14.6,960 是本重载的采样交接量,后续还有消费、混音、FMQ 与后端。

2. 同为一秒,改成双声道后 short 数与字节数怎样变?参考:14.1,96000 short、192000 字节;帧数仍 48000。

3. 为什么 AudioPolicy 不在每个 PCM 数据块的必经数据通道上?参考:14.4,策略选择和管理输出,采样由共享区/混音/HAL 通道搬运。

4. 在非阻塞 write 只返回请求一半时怎样处理?参考:14.2,按实际值推进偏移,剩余继续,保留取消/超时/错误退出。

5. 录音 read 的 releaseBuffer 之后发生什么?参考:14.7,客户端推进消费位置,服务端能复用空间,不是销毁录音对象。

6. 活动输出还在,怎样判断 release 是否泄漏?参考:14.8/14.9,先关联本次 track/port 是否撤销,区分共享输出与本轨道资源;仅凭线程/声卡 fd 存活不能判定。

7. 真正执行示例时,需要保留哪些证据?参考:14.2,记录本次会话、完整日志、超时/取消状态与实际设备身份,分别记录提交、进度、听感和后端证据。

附录 A|完整示例

按 14.2 建立模板后,保留 Gradle 配置并替换这两份文件。界面由 Activity 创建,不依赖模板布局或第三方库。

app/src/main/AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android">    <uses-permission android:name="android.permission.RECORD_AUDIO"/>    <application android:label="AudioChapterDemo" android:theme="@android:style/Theme.Material.Light.NoActionBar">        <activity android:name=".MainActivity" android:exported="true">            <intent-filter>                <action android:name="android.intent.action.MAIN"/>                <category android:name="android.intent.category.LAUNCHER"/>            </intent-filter>        </activity>    </application></manifest>

app/src/main/java/com/example/audiochapter/MainActivity.java

package com.example.audiochapter;import android.Manifest;import android.app.Activity;import android.content.pm.PackageManager;import android.graphics.Insets;import android.media.AudioAttributes;import android.media.AudioDeviceInfo;import android.media.AudioFocusRequest;import android.media.AudioFormat;import android.media.AudioManager;import android.media.AudioRecord;import android.media.AudioTrack;import android.media.MediaRecorder;import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.SystemClock;import android.util.Log;import android.view.WindowInsets;import android.widget.Button;import android.widget.LinearLayout;import android.widget.TextView;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicBoolean;public final class MainActivity extends Activity {    private static final String TAG = "AudioChapter";    private static final int RATE = 48000;    private final ExecutorService worker = Executors.newSingleThreadExecutor();    private Run currentRun;    private int nextRunId;    private static final class Run {        final int id;        final AtomicBoolean canceled = new AtomicBoolean();        Run(int id) {            this.id = id;        }    }    private final Handler main = new Handler(Looper.getMainLooper());    private TextView status;    private boolean destroyed;    @Override public void onCreate(Bundle state) {        super.onCreate(state);        LinearLayout box = new LinearLayout(this);        box.setOrientation(LinearLayout.VERTICAL);        int padding = Math.round(12 * getResources().getDisplayMetrics().density);        if (android.os.Build.VERSION.SDK_INT >= 30) {            box.setOnApplyWindowInsetsListener((view, insets) -> {                Insets bars = insets.getInsets(WindowInsets.Type.systemBars());                view.setPadding(bars.left + padding, bars.top + padding,                        bars.right + padding, bars.bottom + padding);                return insets;            });        } else {            box.setPadding(padding, padding, padding, padding);        }        status = new TextView(this);        status.setText("保持页面在前台;播放1秒,录音0.5秒(只统计,不保存)");        box.addView(status);        Button play = new Button(this); play.setText("播放1秒"); box.addView(play);        Button record = new Button(this); record.setText("录音0.5秒"); box.addView(record);        Button stop = new Button(this); stop.setText("取消"); box.addView(stop);        play.setOnClickListener(v -> launch(false));        record.setOnClickListener(v -> {            if (checkSelfPermission(Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {                requestPermissions(new String[]{Manifest.permission.RECORD_AUDIO}, 14);                status.setText("授权后再点录音;拒绝时保持空闲");                return;            }            launch(true);        });        stop.setOnClickListener(v -> cancelCurrent());        setContentView(box);    }    private void launch(boolean record) {        if (destroyed || currentRun != null) return;        Run run = new Run(++nextRunId);        currentRun = run;        status.setText("第 " + run.id + " 轮运行中,请查看 AudioChapter 日志");        worker.execute(() -> {            try {                if (!run.canceled.get()) {                    if (record) capture(run);                    else playback(run);                }            } catch (Exception e) {                Log.e(TAG, "run=" + run.id + " FAIL " + e, e);            } finally {                log(run, "WORKER_END canceled=" + run.canceled.get());                main.post(() -> {                    if (currentRun != run) return;                    currentRun = null;                    if (!destroyed) status.setText("第 " + run.id + " 轮已收尾,请核对日志");                });            }        });    }    private void cancelCurrent() {        if (currentRun != null) currentRun.canceled.set(true);    }    private static void log(Run run, String text) {        Log.i(TAG, "run=" + run.id + " " + text);    }    private static boolean expired(Run run, long limit) {        return run.canceled.get() || Thread.currentThread().isInterrupted()                || SystemClock.elapsedRealtime() >= limit;    }    private void playback(Run run) throws Exception {        AudioManager manager = getSystemService(AudioManager.class);        AudioAttributes attr = new AudioAttributes.Builder()                .setUsage(AudioAttributes.USAGE_MEDIA).setContentType(AudioAttributes.CONTENT_TYPE_MUSIC).build();        AudioFocusRequest focus = new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)                .setAudioAttributes(attr).setOnAudioFocusChangeListener(change -> {                    log(run, "FOCUS change=" + change);                    if (change < 0) run.canceled.set(true);                }, main).build();        AudioTrack track = null;        boolean focusAttempted = false;        boolean complete = false;        try {            focusAttempted = true;            int granted = manager.requestAudioFocus(focus);            log(run, "FOCUS result=" + granted);            if (granted != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) return;            if (run.canceled.get()) return;            int min = AudioTrack.getMinBufferSize(RATE, AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT);            if (min <= 0) throw new IllegalStateException("minBuffer=" + min);            track = new AudioTrack.Builder().setAudioAttributes(attr)                    .setAudioFormat(new AudioFormat.Builder().setSampleRate(RATE)                            .setChannelMask(AudioFormat.CHANNEL_OUT_MONO).setEncoding(AudioFormat.ENCODING_PCM_16BIT).build())                    .setTransferMode(AudioTrack.MODE_STREAM).setPerformanceMode(AudioTrack.PERFORMANCE_MODE_NONE)                    .setBufferSizeInBytes((Math.max(min, 9600) + 1) / 2 * 2).build();            if (track.getState() != AudioTrack.STATE_INITIALIZED) throw new IllegalStateException("track init");            short[] pcm = new short[RATE];            for (int i = 0; i < pcm.length; i++) pcm[i] = (short)(2000 * Math.sin(2 * Math.PI * 440 * i / RATE));            log(run, "PLAY begin session=" + track.getAudioSessionId() + " frames=" + pcm.length);            if (run.canceled.get()) return;            track.play();            int sent = 0;            long limit = SystemClock.elapsedRealtime() + 4000;            while (sent < pcm.length && !expired(run, limit)) {                int n = track.write(pcm, sent, Math.min(960, pcm.length - sent), AudioTrack.WRITE_NON_BLOCKING);                if (n < 0) throw new IllegalStateException("write=" + n);                sent += n;                if (n == 0) Thread.sleep(5);            }            while (Integer.toUnsignedLong(track.getPlaybackHeadPosition()) < sent && !expired(run, limit)) Thread.sleep(5);            long head = Integer.toUnsignedLong(track.getPlaybackHeadPosition());            AudioDeviceInfo route = track.getRoutedDevice();            complete = sent == RATE && head >= sent && !expired(run, limit);            log(run, "PLAY end submitted=" + sent + " head=" + head + " underrun=" + track.getUnderrunCount()                    + " routeId=" + (route == null ? -1 : route.getId()) + " cancel=" + run.canceled.get()                    + " complete=" + complete);        } finally {            try {                if (track != null) {                    try {                        if (track.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) {                            if (complete) track.stop();                            else {                                track.pause();                                track.flush();                            }                        }                    } finally {                        track.release();                    }                }            } finally {                if (focusAttempted) {                    log(run, "FOCUS abandon=" + manager.abandonAudioFocusRequest(focus));                }            }        }    }    private void capture(Run run) throws Exception {        AudioRecord record = null;        try {            int min = AudioRecord.getMinBufferSize(RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);            if (min <= 0) throw new IllegalStateException("record min=" + min);            record = new AudioRecord.Builder().setAudioSource(MediaRecorder.AudioSource.MIC)                    .setAudioFormat(new AudioFormat.Builder().setSampleRate(RATE)                            .setChannelMask(AudioFormat.CHANNEL_IN_MONO).setEncoding(AudioFormat.ENCODING_PCM_16BIT).build())                    .setBufferSizeInBytes((Math.max(min, 9600) + 1) / 2 * 2).build();            if (record.getState() != AudioRecord.STATE_INITIALIZED) throw new IllegalStateException("record init");            if (run.canceled.get()) return;            record.startRecording();            if (record.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING) throw new IllegalStateException("record start");            int got = 0, peak = 0;            short[] chunk = new short[960];            long limit = SystemClock.elapsedRealtime() + 4000;            log(run, "RECORD begin session=" + record.getAudioSessionId());            while (got < RATE / 2 && !expired(run, limit)) {                int n = record.read(chunk, 0, Math.min(chunk.length, RATE / 2 - got), AudioRecord.READ_NON_BLOCKING);                if (n < 0) throw new IllegalStateException("read=" + n);                for (int i = 0; i < n; i++) peak = Math.max(peak, Math.abs((int)chunk[i]));                got += n;                if (n == 0) Thread.sleep(5);            }            AudioDeviceInfo route = record.getRoutedDevice();            log(run, "RECORD end frames=" + got + " peak=" + peak + " routeId=" + (route == null ? -1 : route.getId())                    + " cancel=" + run.canceled.get() + " complete=" + (got == RATE / 2 && !expired(run, limit)));        } finally {            if (record != null) {                try { if (record.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING) record.stop(); }                finally { record.release(); }            }        }    }    @Override protected void onStop() {        cancelCurrent();        super.onStop();    }    @Override protected void onDestroy() {        destroyed = true;        cancelCurrent();        worker.shutdown();        super.onDestroy();    }}

附录 B|诊断音频会话和设备后端

需要对照系统状态时,用当前设备列表确认序列号。让 App 保持前台,分别在操作前后执行整段命令,保留两次打印的不同目录。若想捕获活跃轨道,在播放或录音进行时另采一份。短轨道可能在 dumpsys 返回前退出,未捕获时按日志中的 session 和时间记下观察停点。

adb devicesexport SERIAL=your-test-serialexport AUDIO_RUN_DIR=$(mktemp -d)(    set -e    adb -s "$SERIAL" shell getprop ro.build.fingerprint > "$AUDIO_RUN_DIR/fingerprint.txt"    adb -s "$SERIAL" shell dumpsys media.audio_policy > "$AUDIO_RUN_DIR/audio-policy.txt"    adb -s "$SERIAL" shell dumpsys media.audio_flinger > "$AUDIO_RUN_DIR/audio-flinger.txt"    adb -s "$SERIAL" shell dumpsys audio > "$AUDIO_RUN_DIR/audio-focus.txt"    printf '%s\n' "$AUDIO_RUN_DIR")

继续追踪 ALSA 或 VirtIO 时,结合 Audio HAL 实例、活动路由、PCM fd、Driver 绑定与 Host 配置。可按设备权限查看 /proc/asound/cards、/proc/asound/pcm,声卡条目本身只能说明系统枚举到了什么。本章底层以固定源码说明机制,当前没有端到端延迟、HAL 绑定或设备实跑记录。

参考资料

• AudioTrack Java 固定版本:Builder、write、play、release。

• AudioTrack JNI 固定版本:setup、writeToTrack、release。

• AudioTrack Native 固定版本:createTrack_l、write、start/stop。

• AudioFlinger 固定版本:createTrack、createRecord。

• AIDL HAL 协议固定版本:命令、回复、FMQ 与 mmap 分支。

• VirtIO PCM 消息处理固定版本:描述符、返回状态与位置推进。

• AIDL Audio HAL 官方说明:作为架构背景;精确函数结论以本文固定代码为准。

• AudioTrack 公开 API。

• AudioRecord 公开 API。

• 音频焦点。

• Android Emulator 扩展控件。

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料