AndroidQ | AudioFlinger

已于 2024-04-13 19:53:37 修改
阅读量1.6k 收藏 9
点赞数
分类专栏： Android系统 # 多媒体框架 文章标签： java android 编解码 音视频
于 2020-08-02 17:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cc289123557/article/details/107578666
版权

Audioflinger负责管理android的所有音频设备，包括输入和输出。在Android Audio系统中，AudioFlinger起到承上启下的作用，上接AudioTrack/AudioRecord/AudioSystem等，下接AudioHal。AudioFlnger对上层会提供各种功能接口调用，对下层会对每个AudioHal设备开启一个独立线程，负责音频数据的管理。本文就依据AudioFlinger的作用来分析部分主要代码。

1 AudioFlinger Service注册

在这里插入图片描述
frameworks\av\media\audioserver\main_audioserver.cpp

int main(int argc __unused, char **argv)
{
...
        sp<IServiceManager> sm = defaultServiceManager();
        ALOGI("ServiceManager: %p", sm.get());
        AudioFlinger::instantiate();------------------audioflinger service注册
...
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
...
}

audioflinger注册后，client就可以使用IAudioFlinger声明的功能了，最主要的功能无非就是获取track和record对象，播放或者录取音频数据，设置或查询音量及其他参数等。

2 创建Playback和Record线程

2.1 Playback线程

对于每个播放设备，audioflinger都会创建一个线程来循环向hal层传输音频数据，具体的接口是openOutput，然后调用openOutput_l来具体创建线程

sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,
                                                        audio_io_handle_t *output,
                                                        audio_config_t *config,
                                                        audio_devices_t deviceType,
                                                        const String8& address,
                                                        audio_output_flags_t flags)
{
    AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);--------1.查询hal音频设备
...
    if (*output == AUDIO_IO_HANDLE_NONE) {
        *output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);-------------------2.分配唯一id
...
    AudioStreamOut *outputStream = NULL;
    status_t status = outHwDev->openOutputStream(
            &outputStream,----------------------------------------------------3.获取stream
            *output,
            deviceType,
            flags,
            config,
            address.string());

    mHardwareStatus = AUDIO_HW_IDLE;

    if (status == NO_ERROR) {
...
        } else {
            sp<PlaybackThread> thread;
...
            } else {---------------------------------------------------------4.创建playback线程
                thread = new MixerThread(this, outputStream, *output, mSystemReady);
                ALOGV("openOutput_l() created mixer output: ID %d thread %p",
                      *output, thread.get());
            }
            mPlaybackThreads.add(*output, thread);---------------------------5.加入vector
...
        }
    }
...
}

线程第一次被引用的时候线程就会运行起来，如下

void AudioFlinger::PlaybackThread::onFirstRef()
{
    run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
}

对于不同类型的设备会创建不同的线程，flag和thread的对应关系如下表：

flagthread
AUDIO_OUTPUT_FLAG_MMAP_NOIRQMmapPlaybackThread
AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOADOffloadThread
AUDIO_OUTPUT_FLAG_DIRECTDirectOutputThread
defaultMixerThread

来看下两个典型的类继承关系：
在这里插入图片描述

线程运行起来会一直在threadLoop中保持循环，playback最主要的功能就是在这里了，这个函数比较长，我们分段来看下

  • 首先是这个大循环，退出循环后，会做一些资源处理
bool AudioFlinger::PlaybackThread::threadLoop()
{
...
    // loopCount is used for statistics and diagnostics.
    for (int64_t loopCount = 0; !exitPending(); ++loopCount)
    {
    	...
    }

    threadLoop_exit();

    if (!mStandby) {
        threadLoop_standby();
        mStandby = true;
    }

    releaseWakeLock();
...
}
  • 循环第一步，判断线程是否有活动的track，是否要进standby等
        { // scope for mLock
            Mutex::Autolock _l(mLock);------作用域内的lock
...
            if (mSignalPending) {
                // A signal was raised while we were unlocked
                mSignalPending = false;
            } else if (waitingAsyncCallback_l()) {
                if (exitPending()) {
                    break;
                }
                bool released = false;
                if (!keepWakeLock()) {
                    releaseWakeLock_l();
                    released = true;
                }
...
                continue;
            }
            if ((mActiveTracks.isEmpty() && systemTime() > mStandbyTimeNs) ||
                                   isSuspended()) {
                // put audio hardware into standby after short delay
                if (shouldStandby_l()) {

                    threadLoop_standby();
...
                }

                if (mActiveTracks.isEmpty() && mConfigEvents.isEmpty()) {
                    // we're about to wait, flush the binder command buffer
                    IPCThreadState::self()->flushCommands();

                    clearOutputTracks();

                    if (exitPending()) {
                        break;
                    }
...
                    mWaitWorkCV.wait(mLock);
                    ALOGV("%s waking up", myName.string());
                    acquireWakeLock_l();
...
                    continue;
                }
            }
            // mMixerStatusIgnoringFastTracks is also updated internally
            mMixerStatus = prepareTracks_l(&tracksToRemove);
...
            activeTracks.insert(activeTracks.end(), mActiveTracks.begin(), mActiveTracks.end());
        } // mLock scope ends
  • 循环第二步，处理track buffer的长度
        if (mBytesRemaining == 0) {
            mCurrentWriteLength = 0;
            if (mMixerStatus == MIXER_TRACKS_READY) {
                // threadLoop_mix() sets mCurrentWriteLength
                threadLoop_mix();
            } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
                        && (mMixerStatus != MIXER_DRAIN_ALL)) {
				...
                if (mSleepTimeUs == 0) {
                    mCurrentWriteLength = mSinkBufferSize;
					...
                }
            }
            // Either threadLoop_mix() or threadLoop_sleepTime() should have set
            // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
            // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
            // or mSinkBuffer (if there are no effects).
            //
            // This is done pre-effects computation; if effects change to
            // support higher precision, this needs to move.
            //
            // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
            // TODO use mSleepTimeUs == 0 as an additional condition.
            if (mMixerBufferValid) {
				...
                memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
                        mNormalFrameCount * (mChannelCount + mHapticChannelCount));
				...
            }

            mBytesRemaining = mCurrentWriteLength;
			...

            // only process effects if we're going to write
            if (mSleepTimeUs == 0 && mType != OFFLOAD) {
				...
            }
        }
  • 循环第三步，开始向hal层传输数据
        if (!waitingAsyncCallback()) {
            // mSleepTimeUs == 0 means we must write to audio hardware
            if (mSleepTimeUs == 0) {
				...
                if (mBytesRemaining) {
					...
                    ret = threadLoop_write();----------------------传输数据
                    const int64_t lastIoEndNs = systemTime();
                    if (ret < 0) {
                        mBytesRemaining = 0;
                    } else if (ret > 0) {
                        mBytesWritten += ret;
                        mBytesRemaining -= ret;
						...
                    }
                } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
                        (mMixerStatus == MIXER_DRAIN_ALL)) {
                    threadLoop_drain();
                }
                if (mType == MIXER && !mStandby) {
				...
                }

            } else {
                ATRACE_BEGIN("sleep");
				...
                ATRACE_END();
            }
        }
  • 循环第四步，处理不活动的track等
        threadLoop_removeTracks(tracksToRemove);
        tracksToRemove.clear();
        clearOutputTracks();
        effectChains.clear();

2.2 Record线程

创建Record线程的函数为openInput->openInput_l

sp<AudioFlinger::ThreadBase> AudioFlinger::openInput_l(audio_module_handle_t module,
                                                         audio_io_handle_t *input,
                                                         audio_config_t *config,
                                                         audio_devices_t devices,
                                                         const String8& address,
                                                         audio_source_t source,
                                                         audio_input_flags_t flags,
                                                         audio_devices_t outputDevice,
                                                         const String8& outputDeviceAddress)
{
    AudioHwDevice *inHwDev = findSuitableHwDev_l(module, devices);---------------查询hal设备
...
    if (*input == AUDIO_IO_HANDLE_NONE) {
        *input = nextUniqueId(AUDIO_UNIQUE_ID_USE_INPUT);------------------------分配唯一id
    } else if (audio_unique_id_get_use(*input) != AUDIO_UNIQUE_ID_USE_INPUT) {
...
    }
...
    status_t status = inHwHal->openInputStream(---------------------------------打开stream
            *input, devices, &halconfig, flags, address.string(), source,
            outputDevice, outputDeviceAddress, &inStream);
...
    if (status == NO_ERROR && inStream != 0) {
        AudioStreamIn *inputStream = new AudioStreamIn(inHwDev, inStream, flags);
        if ((flags & AUDIO_INPUT_FLAG_MMAP_NOIRQ) != 0) {
...
        } else {
...
            sp<RecordThread> thread = new RecordThread(this, inputStream, *input, mSystemReady);-----创建线程
            mRecordThreads.add(*input, thread);------------------------------加入vector
...
        }
    }
...
}

Record线程根据设备的类型可以分两种

flagthread
AUDIO_INPUT_FLAG_MMAP_NOIRQMmapCaptureThread
defaultRecordThread
这两种类型的类继承关系如下
在这里插入图片描述
Record线程的threadloop也是在一个大循环中，读取音频数据然后分别分发给RecordTrack

3 创建AudioTrack和AudioRecord

3.1 AudioTrack

用户要播放音频，就要创建一个AudioTrack对象，具体调用步骤为AudioTrack@AudioTrack->set@AudioTrack->createTrack_l@AudioTrack

status_t AudioTrack::createTrack_l()
{
...
    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
...
    sp<IAudioTrack> track = audioFlinger->createTrack(input,
                                                      output,
                                                      &status);
...
	mAudioTrack = track;
...
}

IAudioTrack封装了binder通信的接口，这里通过binder通信机制来获取binder句柄，最终来和service端通信，这个还是要看一下

    virtual sp<IAudioTrack> createTrack(const CreateTrackInput& input,
                                        CreateTrackOutput& output,
                                        status_t *status)
    {
        Parcel data, reply;
        sp<IAudioTrack> track;
        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());

        if (status == nullptr) {
            return track;
        }

        input.writeToParcel(&data);

        status_t lStatus = remote()->transact(CREATE_TRACK, data, &reply);----通过AudioFlinger获取数据
        if (lStatus != NO_ERROR) {
            ALOGE("createTrack transaction error %d", lStatus);
            *status = DEAD_OBJECT;
            return track;
        }
        *status = reply.readInt32();
        if (*status != NO_ERROR) {
            ALOGE("createTrack returned error %d", *status);
            return track;
        }
        track = interface_cast<IAudioTrack>(reply.readStrongBinder());-------数据转化为binder句柄
        if (track == 0) {
            ALOGE("createTrack returned an NULL IAudioTrack with status OK");
            *status = DEAD_OBJECT;
            return track;
        }
        output.readFromParcel(&reply);
        return track;
    }

接下来看AudioFlinger那边的实现

sp<IAudioTrack> AudioFlinger::createTrack(const CreateTrackInput& input,
                                          CreateTrackOutput& output,
                                          status_t *status)
{
...
    {
...
        track = thread->createTrack_l(client, streamType, localAttr, &output.sampleRate,
                                      input.config.format, input.config.channel_mask,
                                      &output.frameCount, &output.notificationFrameCount,
                                      input.notificationsPerBuffer, input.speed,
                                      input.sharedBuffer, sessionId, &output.flags,
                                      callingPid, input.clientInfo.clientTid, clientUid,
                                      &lStatus, portId);
...
        }
...
    // return handle to client
    trackHandle = new TrackHandle(track);
...
    return trackHandle;
}

然后需要把track对象加入到PlaybackThread的vector中，调用的函数为start，最终会调用到Bn端的start实现，我们来看下Bn端继承的对象
在这里插入图片描述

status_t AudioFlinger::TrackHandle::start() {
    return mTrack->start();--------mTrack的类型为PlaybackThread::Track
}

status_t AudioFlinger::PlaybackThread::Track::start(AudioSystem::sync_event_t event __unused,
                                                    audio_session_t triggerSession __unused)
{
	...
    if (thread != 0) {
		...
        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
		...
        status = playbackThread->addTrack_l(this);
		...
    } else {
        status = BAD_VALUE;
    }
...
}

调用PlaybackThread来加入到线程中

status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
{
    status_t status = ALREADY_EXISTS;

    if (mActiveTracks.indexOf(track) < 0) {
		...
        mActiveTracks.add(track);---------正式加入到线程中
		...
    }
	...
}

3.2 AudioRecord

对于AudioRecord就直接来看start的实现

status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
                                           AudioSystem::sync_event_t event,
                                           audio_session_t triggerSession)
{
	...

    {
		...
        mActiveTracks.add(recordTrack);
		...
    }
}
gomogomono
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 蓝牙 Audio Flinger 简介
手机-手表蓝牙开发工程师的博客
04-19 743
android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙A2dp-Avrcp初始化-连接-播放源码分析文档大全 - 点击下载 AudioFlinger简介 AudioPolicyService与AudioFlinger是Android音频系统的两大基本服务。前者是音频系统策略的制定者，负责音频设备切换的策略抉择、音量调节策略等；后者是音频系统策略的执行者，负责音频流设备的管理及音频流数据的处理传输，所以AudioFlinger也被认为是And
Android Audio基础——AudioFlinger介绍（五）
小旭的专栏
05-11 579
IAudioFlinger.cpp 是 AudioFlinger 给上层提供的接口。AudioFlinger 服务启动后，其他进程可以通过 ServiceManager 来获取其代理对象 IAudioFlinger，通过 IAudioFlinger 可以向 AudioFlinger 发出各种服务请求，从而完成自己的音频业务。源码位置：/frameworks/av/media/libaudioclient/IAudioFlinger.cpp// 创建Track// 创建Record。
Android Audio基础——AudioFlinger回放录制线程（八）
最新发布
小旭的专栏
05-20 389
PlaybackThread 和 RecordThread 的基类。录制线程类，由 ThreadBase 派生。回放线程基类，同由 ThreadBase 派生。混音回放线程类，由 PlaybackThread 派生，负责处理标识为 AUDIO_OUTPUT_FLAG_PRIMARY、AUDIO_OUTPUT_FLAG_FAST、AUDIO_OUTPUT_FLAG_DEEP_BUFFER 的音频流，MixerThread 可以把多个音轨的数据混音后再输出。
Android音频系统AudioFlinger详解 超级干货
WolfKingzyh的博客
01-16 3257
深入理解Android音频框架AudioTrack到AudioFlinger、AudioMix的整个过程
Android音频管理：AudioFlinger分析
u013490411的博客
08-17 1万+
1.Android音频框架概述 Audio是Android平台非常重要的一个组成部分，负责音频数据的输出采集，音频流的控制，音量调节，音频设备的管理等。我们先来简单介绍一下播放一首音乐的流程：首先应用层点击播放音乐的时候应用会通过mediaplayer接口去启动Android系统的播放器NuPlayer。其实mp3或者flac等格式的音频文件就是一个特殊的压缩文件，所以播放一个音频文件首先要做的就是要去解压缩，Nuplayer通过mediaextractor（高通的有自己的解封装模块mmparser）去解封
Android 音频系统（二）之 AudioFlinger
|~~~热爱生活、努力学习的小伙汁~~~|
03-24 4278
3. AudioFlinger 概述 AudioPolicyService 与 AudioFlinger 是 Android 音频系统的两大基本服务。 AudioPolicyService 是音频系统策略的制定者，负责音频设备切换的策略抉择、音量调节策略等； AudioFlinger 是音频系统策略的执行者，负责音频流设备的管理及音频流数据的处理传输， 所以 AudioFlinger 也被认为是 ...
【初学音频】Android的Audio系统之AudioFlinger
TinyHorse的博客
09-06 3647
AudioTrack和AudioFlinger
Android P Audio系统笔记：AudioPolicy&AudioFlinger初始化
zjy764219923的专栏
09-27 1280
AudioPolicy&AudioFlinger初始化
AudioFlinger 音频播放流程解析
我的博客
03-31 907
AudioFlinger 音频播放流程解析
Android 12 AudioFlinger 分析（RK3588）
03-12
在Android操作系统中，AudioFlinger是音频服务的核心组件，它负责处理音频的混合、路由、硬件交互以及与其他音频服务的协作。本分析将专注于在Android 12版本中，AudioFlinger在Rockchip RK3588处理器上的实现和优化...
AudioFlinger.svg
06-12
AudioFlinger.svg UML顺序图
android audioflinger.pdf
04-02
android audioflinger.pdf
安卓audio-audioflinger、audiopolicy策略加载
08-31
Android音频框架通过AudioPolicyService和AudioFlinger协同工作，实现音频策略的制定和执行。AudioPolicyService作为策略中心，依据audio_policy.conf文件制定出适应不同场景的音频策略，而AudioFlinger则负责将...
AudioFlinger流程分析
u012906122的专栏
06-06 1524
转载自: https://blog.csdn.net/Innost/article/details/6142812
【初学音频】Android的Audio系统
TinyHorse的博客
08-16 1957
主要是硬件部分balabala
Android 音频源码分析——AudioFlinger
奋斗的菜鸟ing
04-07 2443
Android 音频源码分析——AndroidRecord录音（一） Android 音频源码分析——AndroidRecord录音（二） Android 音频源码分析——AndroidRecord音频数据传输流程 Android 音频源码分析——audioserver启动 Android 音频源码分析——AudioFlinger 混音：把多种来源的声音，整合至一个立体音轨或单音轨中。 AudioFlinger和AudioPolicyService是音频中的两大服务，这里先整理下AudioFlinger。
Android Audio System 之二：AudioFlinger
热门推荐
DroidPhone的专栏
10-19 4万+
引言     AudioFlinger是Android音频系统的两大服务之一，另一个服务是AudioPolicyService，这两大服务都在系统启动时有MediaSever加载，加载的代码位于：frameworks/base/media/mediaserver/main_mediaserver.cpp。AudioPolicyService的相关内容请参考另一编文章：《Android Audio System 之三： AudioPolicyService 和 AudioPolicyManager 》http
AudioFlinger、AudioPolicyService和AudioPolicyManager之间的关系？
jackzhouyu的专栏
12-22 5707
AudioFlinger和AudioPolicyService属于binder服务，而AudioPolicyManager是AudioPolicyService服务进程下的一个独立功能模块，该模块可以由厂家自行实现(但必须遵循aosp的接口定义)，最后提供so库，由AudioPolicyService服务load进来调用即可。
android12 audioflinger
09-05
Android 12中的AudioFlinger是一个重要的音频框架，用于处理和管理设备的音频功能。它充当了音频系统的中央控制器，负责协调应用程序和硬件之间的交互。 在Android 12中，AudioFlinger经历了一些改进和新增功能。首先是音频路由管理的增强。它引入了新的音频设备拓扑，使系统能够更好地识别和管理连接的外部设备如耳机、扬声器等，并进行自适应路由切换。 其次，Android 12中的AudioFlinger对音频输出效果的控制也进行了改进。它引入了新的音频特效框架和API，使开发者能够更方便地对音频进行处理和增强，提供更好的音质和用户体验。 此外，Android 12的AudioFlinger还加强了对音频捕获和录制功能的支持。它提供了更高的音频采样率和位深度选项，提高了录制音频的质量，并增加了对多通道录制和音频源选择的支持。 最后，Android 12中的AudioFlinger还改进了音频会话管理功能。它提供了更细粒度的音频焦点管理，使应用程序之间更好地协调和共享音频资源，提供更流畅的音频体验。 总的来说，Android 12中的AudioFlinger通过增强音频路由管理、引入音频特效框架、提供更好的录制功能支持以及改进音频会话管理等方式，为开发者和用户提供了更优秀的音频功能和体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值