Android AAudio源码分析（一）

Android AAudio源码分析（一）

---

提示：再读文章之前可以先学习一下Binder和MMAP的知识

---

前言

因为网上目前还没有关于安卓AAudio方面的原理分析，所以笔者通过研究安卓源码，总结了一些偏向于底层的一些东西，希望可以帮助到大家

---

一、AAudio是什么

AAudio 是在 Android O 版本中引入的全新 Android C API。此 API 专为需要低延迟的高性能音频应用而设计。应用通过读取数据并将数据写入流来与 AAudio 进行通信

二、AAudio源码解析

1.启动

（1）系统服务启动main_audioserver.cpp

xref: /frameworks/av/media/audioserver/main_audioserver.cpp

// AAudioService should only be used in OC-MR1 and later.
// And only enable the AAudioService if the system MMAP policy explicitly allows it.
// This prevents a client from misusing AAudioService when it is not supported.
//AAudioService只能在OC-MR1及更高版本中使用
//并且只有在系统MMAP策略明确允许的情况下才启用AAudioService
//这可以防止客户端在不支持AAudioService时误用它

aaudio_policy_t mmapPolicy = property_get_int32(AAUDIO_PROP_MMAP_POLICY,
                                                AAUDIO_POLICY_NEVER);
if (mmapPolicy == AAUDIO_POLICY_AUTO || mmapPolicy == AAUDIO_POLICY_ALWAYS) {
     
    AAudioService::instantiate();
}

可以看到是有一个AAudioService来初始化的。

（2）AAudioService是什么？

先来看它都继承了什么：
binder不用多说，BnAAudioService和AAudioServiceInterface要看一下

xref: /frameworks/av/services/oboeservice/AAudioService.h

class AAudioService :
    public BinderService<AAudioService>,
    public BnAAudioService,
    public aaudio::AAudioServiceInterface
{
     
    friend class BinderService<AAudioService>;

先来看BnAAudioService：

从名字来看就是一个服务
这个类写在了IAAudioService.h的头文件中
而client的各种使用AAudio的操作，都通过层层调用及参数包装汇聚到onTransact()，再由onTransact()分发到真正的目标方法执行

xref: /frameworks/av/media/libaaudio/src/binding/IAAudioService.h

class BnAAudioService : public BnInterface<IAAudioService> {
     
public:
    virtual status_t onTransact(uint32_t code, const Parcel& data,
                                Parcel* reply, uint32_t flags = 0);

};

具体都有哪些方法呢？

class IAAudioService : public IInterface {
     
public:

    DECLARE_META_INTERFACE(AAudioService);

    // Register an object to receive audio input/output change and track notifications.
    // For a given calling pid, AAudio service disregards any registrations after the first.
    // Thus the IAAudioClient must be a singleton per process.
    virtual void registerClient(const sp<IAAudioClient>& client) = 0;

    /**
     * @param request info needed to create the stream
     * @param configuration contains information about the created stream
     * @return handle to the stream or a negative error
     */
    virtual aaudio::aaudio_handle_t openStream(const aaudio::AAudioStreamRequest &request,
                                     aaudio::AAudioStreamConfiguration &configurationOutput) = 0;

    virtual aaudio_result_t closeStream(aaudio::aaudio_handle_t streamHandle) = 0;

    /* Get an immutable description of the in-memory queues
    * used to communicate with the underlying HAL or Service.
    */
    virtual aaudio_result_t getStreamDescription(aaudio::aaudio_handle_t streamHandle,
                                               aaudio::AudioEndpointParcelable &parcelable) = 0;

    /**
     * Start the flow of data.
     * This is asynchronous. When complete, the service will send a STARTED event.
     */
    virtual aaudio_result_t startStream(aaudio::aaudio_handle_t streamHandle) = 0;

    /**
     * Stop the flow of data such that start() can resume without loss of data.
     * This is asynchronous. When complete, the service will send a PAUSED event.
     */
    virtual aaudio_result_t pauseStream(aaudio::aaudio_handle_t streamHandle) = 0;

    /**
     * Stop the flow of data such that the data currently in the buffer is played.
     * This is asynchronous. When complete, the service will send a STOPPED event.
     */
    virtual aaudio_result_t stopStream(aaudio::aaudio_handle_t streamHandle) = 0;

    /**
     *  Discard any data held by the underlying HAL or Service.
     * This is asynchronous. When complete, the service will send a FLUSHED event.
     */
    virtual aaudio_result_t flushStream(aaudio::aaudio_handle_t streamHandle) = 0;

    /**
     * Manage the specified thread as a low latency audio thread.
     */
    virtual aaudio_result_t registerAudioThread(aaudio::aaudio_handle_t streamHandle,
                                              pid_t clientThreadId,
                                              int64_t periodNanoseconds) = 0;

    virtual aaudio_result_t unregisterAudioThread(aaudio::aaudio_handle_t streamHandle,
                                                pid_t clientThreadId) = 0;
};

这些函数能够让用户很方便的使用AAudio实现播放或者录制等等

顺便看一下IAAudioService.cpp文件都干了啥？
xref: /frameworks/av/media/libaaudio/src/binding/IAAudioService.cpp

/**
 * This is used by the AAudio Client to talk to the AAudio Service.
 *
 * The order of parameters in the Parcels must match with code in AAudioService.cpp.
 */
class BpAAudioService : public BpInterface<IAAudioService>
{
     
public:
    explicit BpAAudioService(const sp<IBinder>& impl) 
        : BpInterface<IAAudioService>(impl)
    {
     
    }

    void registerClient(const sp<IAAudioClient>& client) override
    {
     
        Parcel data, reply;
        data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
        data.writeStrongBinder(IInterface::asBinder(client));
        remote()->transact(REGISTER_CLIENT, data, &reply);
    }

    aaudio_handle_t openStream(const aaudio::AAudioStreamRequest &request,
                               aaudio::AAudioStreamConfiguration &configurationOutput) override {
     
        Parcel data, reply;
        // send command
        data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
        // request.dump();
        request.writeToParcel(&data);
        status_t err = remote()->transact(OPEN_STREAM, data, &reply);
        if (err != NO_ERROR) {
     
            ALOGE("BpAAudioService::client openStream transact failed %d", err);
            return AAudioConvert_androidToAAudioResult(err);
        }
        // parse reply
        aaudio_handle_t stream;
        err = reply.readInt32(&stream);
        if (err != NO_ERROR) {
     
            ALOGE("BpAAudioService::client transact(OPEN_STREAM) readInt %d", err);
            return AAudioConvert_androidToAAudioResult(err);
        } else if (stream < 0) {
     
            ALOGE("BpAAudioService::client OPEN_STREAM passed stream %d", stream);
            return stream;
        }
        err = configurationOutput.readFromParcel(&reply);
        if (err != NO_ERROR) {
     
            ALOGE("BpAAudioService::client openStream readFromParcel failed %d", err);
            closeStream(stream);
            return AAudioConvert_androidToAAudioResult(err);
        }
        return stream;
    }

...

};

// Implement an interface to the service.
// This is here so that you don't have to link with libaaudio static library.
IMPLEMENT_META_INTERFACE(AAudioService, "IAAudioService");

// The order of parameters in the Parcels must match with code in BpAAudioService

status_t BnAAudioService::onTransact(uint32_t code, const Parcel& data,
                                        Parcel* reply, uint32_t flags) {
     
    aaudio_handle_t streamHandle;
    aaudio::AAudioStreamRequest request;
    aaudio::AAudioStreamConfiguration configuration;
    pid_t tid;
    int64_t nanoseconds;
    aaudio_result_t result;
    status_t status = NO_ERROR;
    ALOGV("BnAAudioService::onTransact(%i) %i", code, flags);

    switch(code) {
     
        case REGISTER_CLIENT: {
     
            CHECK_INTERFACE(IAAudioService, data, reply);
            sp<IAAudioClient> client = interface_cast<IAAudioClient>(
                    data.readStrongBinder());
            registerClient(client);
            return NO_ERROR;
        } break;

        case OPEN_STREAM: {
     
            CHECK_INTERFACE(IAAudioService, data, reply);
            request.readFromParcel(&data);
            result = request.validate();
            if (result != AAUDIO_OK) {
     
                streamHandle = result;
            } else {
     
                //ALOGD("BnAAudioService::client openStream request dump --------------------");
                //request.dump();
                // Override the uid and pid from the client in case they are incorrect.
                request.setUserId(IPCThreadState::self()->getCallingUid());
                request.setProcessId(IPCThreadState::self()->getCallingPid());
                streamHandle = openStream(request, configuration);
                //ALOGD("BnAAudioService::onTransact OPEN_STREAM server handle = 0x%08X",
                //        streamHandle);
            }
            reply->writeInt32(streamHandle);
            configuration.writeToParcel(reply);
            return NO_ERROR;
        } break;

...

        default:
            // ALOGW("BnAAudioService::onTransact not handled %u", code);
            return BBinder::onTransact(code, data, reply, flags);
    }
}

} /* namespace android */

其中声明了BpAAudioService类，实现了这些函数
最终还是经过transact调到了BnAAudioService，然后根据参数分发处理
整个过程用到了跨进程通信的方法：Binder

再来看AAudioService的另一个继承：AAudioServiceInterface

xref: /frameworks/av/media/libaaudio/src/binding/AAudioServiceInterface.h

/**
 * This has the same methods as IAAudioService but without the Binder features.
 *
 * It allows us to abstract the Binder interface and use an AudioStreamInternal
 * both in the client and in the service.
 */

只看注释，因为定义的方法和IAAudioService里面几乎一样，就是少了Binder
所以也就可以单纯的把它看作一个接口，客户端和服务端都有继承AAudioServiceInterface，统一了客户端和服务端的接口

（3）其他几个重要的类的介绍

IAAudioClient：
xref: /frameworks/av/media/libaaudio/src/binding/AAudioBinderClient.h

通过绑定器与服务对话来实现AAudioServiceInterface里面的方法，就是我们上面说到的客户端
在其内部通过从SM（ServiceManager）里面拿到AAudioService的引用，绑定之后使用

class AAudioBinderClient : public virtual android::RefBase
        , public AAudioServiceInterface
        , public android::Singleton<AAudioBinderClient> {
     

加上它的继承的一些类来看，会更加一目了然。

AAudioBinderClient
xref: /frameworks/av/media/libaaudio/src/binding/IAAudioClient.h

这个类是用来service与client通信的，其中主要内容就是流 状态的变化

// Interface (our AIDL) - client methods called by service
class IAAudioClient : public IInterface {
     
public:

    DECLARE_META_INTERFACE(AAudioClient);

    virtual void onStreamChange(aaudio::aaudio_handle_t handle, int32_t opcode, int32_t value) = 0;

};

class BnAAudioClient : public BnInterface<IAAudioClient> {
     
public:
    virtual status_t onTransact(uint32_t code, const Parcel& data,
                                Parcel* reply, uint32_t flags = 0);
};

} /* namespace android */

总结：
关于AAudioSevice，里面用了很多Binder的知识，把Binder看透了也就了解了这整个调用的流程

Binder流程如图：

2.工作原理

AAudioService提供了很多供我们使用它的方法，接下来就是对其中几个重要的方法进行剖析，了解其工作原理

（1）openStream：

先来看一张时序图：

打开流的过程如图所示，其中主要会分两种情况：
共享模式：多个音频流可以同时访问该音频设备，该模式下音频的延迟略高于独占模式
独占模式：只有该音频流能访问该音频设备，其它音频流拒绝访问，该模式下 音频流 性能高 , 延迟低
注意：如果不再使用该音频设备，需要马上释放音频流，以免影响其它音频流访问该音频设备（独占模式）

接下来来看代码：
xref: /frameworks/av/services/oboeservice/AAudioService.cpp

aaudio_handle_t AAudioService::openStream(const aaudio::AAudioStreamRequest &request,
                                          aaudio::AAudioStreamConfiguration &configurationOutput) {
     
    aaudio_result_t result = AAUDIO_OK;
    sp<AAudioServiceStreamBase> serviceStream;
    const AAudioStreamConfiguration &configurationInput = request.getConstantConfiguration();
    bool sharingModeMatchRequired = request.isSharingModeMatchRequired();
    aaudio_sharing_mode_t sharingMode = configurationInput.getSharingMode();

    // Enforce limit on client processes.
    //对客户端进程实施限制
    //这里面规定每个进程都有最大音频流数
    //当超过这个最大音频流数量时，将不能继续执行函数
    pid_t pid = request.getProcessId();
    if (pid != mAudioClient.clientPid) {
     
        int32_t count = AAudioClientTracker::getInstance().getStreamCount(pid);
        if (count >= MAX_STREAMS_PER_PROCESS) {
     
            ALOGE("openStream(): exceeded max streams per process %d >= %d",
                  count,  MAX_STREAMS_PER_PROCESS);
            return AAUDIO_ERROR_UNAVAILABLE;
        }
    }
    
    //传输模式检测，只允许共享模式或者独占模式
    if (sharingMode != AAUDIO_SHARING_MODE_EXCLUSIVE && sharingMode != AAUDIO_SHARING_MODE_SHARED) {
     
        ALOGE("openStream(): unrecognized sharing mode = %d", sharingMode);
        return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
    }

    //独占模式的情况
    if (sharingMode == AAUDIO_SHARING_MODE_EXCLUSIVE) {
     
        // only trust audioserver for in service indication
        //这个inService变量代表着这个流是不是被AAudioService单独打开的（没有客户端）
        bool inService = false;
        if (mAudioClient.clientPid == IPCThreadState::self()->getCallingPid() &&
                mAudioClient.clientUid == IPCThreadState::self()->getCallingUid()) {
     
            inService = request.isInService();
        }
        //之后就可以new一个独占模式专用的对象来打开流
        //传递了两个参数：一个是AAudioService的指针，一个就是inService
        //在之后对流进行其他操作时会用到inService这个参数
        serviceStream = new AAudioServiceStreamMMAP(*this, inService);
        result = serviceStream->open(request);
        if (result != AAUDIO_OK) {
     
            // Clear it so we can possibly fall back to using a shared stream.
            ALOGW("openStream(), could not open in EXCLUSIVE mode");
            serviceStream.clear();
        }
    }

    // if SHARED requested or if EXCLUSIVE failed
    //接下来是共享模式打开流
    //当创建独占模式的流失败并且传输模式与请求的模式不同时，会以共享模式打开流
    if (sharingMode == AAUDIO_SHARING_MODE_SHARED
         || (serviceStream.get() == nullptr && !sharingModeMatchRequired)) {
     
        serviceStream =  new AAudioServiceStreamShared(*this);
        result = serviceStream->open(request);
    }
    
    //创建不成功
    if (result != AAUDIO_OK) {
     
        serviceStream.clear();
        ALOGE("openStream(): failed, return %d = %s",
              result, AAudio_convertResultToText(result));
        return result;
    } else {
     
        //创建成功
        //生成这个AAduio流服务的句柄返回供客户端调用
        aaudio_handle_t handle = mStreamTracker.addStreamForHandle(serviceStream.get());
        ALOGD("openStream(): handle = 0x%08X", handle);
        serviceStream->setHandle(handle);
        pid_t pid = request.getProcessId();
        //将这个创建好的音频流注册为客户端用来发送数据
        AAudioClientTracker::getInstance().registerClientStream(pid, serviceStream);
        configurationOutput.copyFrom(*serviceStream);
        return handle;
    }
}

接下来分析独占模式下是什么情况
xref: /frameworks/av/services/oboeservice/AAudioServiceStreamMMAP.cpp

//这些对应于独占模式MMAP客户端流。
//它独占使用一个AAudioServiceEndpointMMAP与底层设备或端口通信。
//这个服务流的核心就是使用MMAP缓冲区

//继承了AAudioServiceStreamBase
class AAudioServiceStreamMMAP : public AAudioServiceStreamBase

// Open stream on HAL and pass information about the shared memory buffer back to the client.
//打开HAL上的流并将有关共享内存缓冲区的信息传递回客户端。
aaudio_result_t AAudioServiceStreamMMAP::open(const aaudio::AAudioStreamRequest &request) {
     

    sp<AAudioServiceStreamMMAP> keep(this);
    
    //带着独占模式的参数，调用AAudioServiceStreamBase的open函数
    aaudio_result_t result = AAudioServiceStreamBase::open(request,
                                                           AAUDIO_SHARING_MODE_EXCLUSIVE);
    if (result != AAUDIO_OK) {
     
        return result;
    }

    //把这个mServiceEndpointWeak升级为强指针，看它是不是还存活
    //mServiceEndpoint变量可以由多个线程访问
    //因此，我们通过本地向智能指针升级弱指针来访问它，这是线程安全的
    sp<AAudioServiceEndpoint> endpoint = mServiceEndpointWeak.promote();
    if (endpoint == nullptr) {
     
        ALOGE("%s() has no endpoint", __func__);
        return AAUDIO_ERROR_INVALID_STATE;
    }
    
    //注册这个AAudioServiceStreamMMAP流
    //AAudioServiceEndpoint（endpoint）由AAudioServiceStreamBase的子类使用，与底层音频设备或端口通信
    //保证流的操作是线程安全的
    result = endpoint->registerStream(keep);
    if (result != AAUDIO_OK) {
     
        return result;
    }

    setState(AAUDIO_STREAM_STATE_OPEN);

    return AAUDIO_OK;
}

继续分析AAudioServiceStreamBase::open
xref: /frameworks/av/services/oboeservice/AAudioServiceStreamBase.cpp

//AAudioServiceStreamBase的每个实例都对应于一个客户机流。
//它使用AAudioServiceEndpoint的子类与底层设备或端口通信。

aaudio_result_t AAudioServiceStreamBase::open(const aaudio::AAudioStreamRequest &request,
                                              aaudio_sharing_mode_t sharingMode) {
     
    AAudioEndpointManager &mEndpointManager = AAudioEndpointManager::getInstance();
    aaudio_result_t result = AAUDIO_OK;

    mMmapClient.clientUid = request.getUserId();
    mMmapClient.clientPid = request.getProcessId();
    mMmapClient.packageName.setTo(String16("")); // TODO What should we do here?

    // Limit scope of lock to avoid recursive lock in close().
    //限制锁的作用域以避免close（）中的递归锁。
    //判断mUpMessageQueueLock是否为空，也就是说看它是否是第一次打开流
    {
     
        std::lock_guard<std::mutex> lock(mUpMessageQueueLock);
        if (mUpMessageQueue != nullptr) {
     
            ALOGE("%s() called twice", __func__);
            return AAUDIO_ERROR_INVALID_STATE;
        }

        //创建共享内存
        mUpMessageQueue = new SharedRingBuffer();
        result = mUpMessageQueue->allocate(sizeof(AAudioServiceMessage),
                                           QUEUE_UP_CAPACITY_COMMANDS);
        if (result != AAUDIO_OK) {
     
            goto error;
        }

        // This is not protected by a lock because the stream cannot be
        // referenced until the service returns a handle to the client.
        // So only one thread can open a stream.
        //这不受锁的保护，因为在服务向客户端返回句柄之前，流不能被引用。
        //所以只有一个线程可以打开一个流。
        mServiceEndpoint = mEndpointManager.openEndpoint(mAudioService,
                                                         request,
                                                         sharingMode);
        if (mServiceEndpoint == nullptr) {
     
            ALOGE("%s() openEndpoint() failed", __func__);
            result = AAUDIO_ERROR_UNAVAILABLE;
            goto error;
        }
        // Save a weak pointer that we will use to access the endpoint.
        //保存将用于访问端口的弱指针
        //然后这个弱指针将会在AAudioServiceStreamMMAP里面转化为强指针
        mServiceEndpointWeak = mServiceEndpoint;

        //获取每次写入的帧数
        mFramesPerBurst = mServiceEndpoint->getFramesPerBurst();
        copyFrom(*mServiceEndpoint);
    }
    return result;

error:
    close();
    return result;
}

继续分析mEndpointManager.openEndpoint
xref: /frameworks/av/services/oboeservice/AAudioEndpointManager.cpp

sp<AAudioServiceEndpoint> AAudioEndpointManager::openEndpoint(AAudioService &audioService,
                                        const aaudio::AAudioStreamRequest &request,
                                        aaudio_sharing_mode_t sharingMode) {
     
    if (sharingMode == AAUDIO_SHARING_MODE_EXCLUSIVE) {
     
        return openExclusiveEndpoint(audioService, request);
    } else {
     
        return openSharedEndpoint(audioService, request);
    }
}

在这里面做了个判断，依据我们传入的sharingMode来做区分
先看独占模式，也就是openExclusiveEndpoint这个方法

sp<AAudioServiceEndpoint> AAudioEndpointManager::openExclusiveEndpoint(
        AAudioService &aaudioService,
        const aaudio::AAudioStreamRequest &request) {
     

    std::lock_guard<std::mutex> lock(mExclusiveLock);

    const AAudioStreamConfiguration &configuration = request.getConstantConfiguration();

    // Try to find an existing endpoint.
    //遍历mExclusiveStreams看是否存在当前configuration所匹配的流
    sp<AAudioServiceEndpoint> endpoint = findExclusiveEndpoint_l(configuration);

    // If we find an existing one then this one cannot be exclusive.
    //如果找到了，就不允许再创建了，返回空
    if (endpoint.get() != nullptr) {
     
        ALOGW("openExclusiveEndpoint() already in use");
        // Already open so do not allow a second stream.
        return nullptr;
    //没有匹配的流，则可以创建
    } else {
     
        sp<AAudioServiceEndpointMMAP> endpointMMap = new AAudioServiceEndpointMMAP(aaudioService);
        ALOGV("openExclusiveEndpoint(), no match so try to open MMAP %p for dev %d",
              endpointMMap.get(), configuration.getDeviceId());
        //AAudioServiceEndpointMMAP继承了AAudioServiceEndpoint
        endpoint = endpointMMap;
        
        //调用AAudioServiceEndpointMMAP的open函数
        aaudio_result_t result = endpoint->open(request);
        if (result != AAUDIO_OK) {
     
            ALOGE("openExclusiveEndpoint(), open failed");
            endpoint.clear();
        } else {
     
            //创建成功加入mExclusiveStreams
            mExclusiveStreams.push_back(endpointMMap);
            mExclusiveOpenCount++;
        }
    }

    if (endpoint.get() != nullptr) {
     
        // Increment the reference count under this lock.
        //增加此锁下的引用计数
        endpoint->setOpenCount(endpoint->getOpenCount() + 1);
    }
    return endpoint;
}

层层调用，快到头了
AAudioServiceStreamMMAP使用AAudioServiceEndpointMMAP通过AudioFlinger访问MMAP设备
AAudioServiceEndpointMMAP的open函数：
xref: /frameworks/av/services/oboeservice/AAudioServiceEndpointMMAP.cpp

aaudio_result_t AAudioServiceEndpointMMAP::open(const aaudio::AAudioStreamRequest &request) {
     
    aaudio_result_t result = AAUDIO_OK;
    audio_config_base_t config;
    audio_port_handle_t deviceId;

    //读取系统属性
    //获得系统每次出现MMAP的最小微秒
    int32_t burstMinMicros = AAudioProperty_getHardwareBurstMinMicros();
    int32_t burstMicros = 0;

    copyFrom(request.getConstantConfiguration());

    //获取这次请求的音频流方向：输出/输入
    aaudio_direction_t direction = getDirection();

    //转换为内部值
    const audio_content_type_t contentType =
            AAudioConvert_contentTypeToInternal(getContentType());
    // Usage only used for OUTPUT
    //输入和输出有区别
    //输出情况下source为默认值
    //输入情况下usage为默认值
    const audio_usage_t usage = (direction == AAUDIO_DIRECTION_OUTPUT)
            ? AAudioConvert_usageToInternal(getUsage())
            : AUDIO_USAGE_UNKNOWN;
    const audio_source_t source = (direction == AAUDIO_DIRECTION_INPUT)
            ? AAudioConvert_inputPresetToAudioSource(getInputPreset())
            : AUDIO_SOURCE_DEFAULT;

    const audio_attributes_t attributes = {
     
            .content_type = contentType,
            .usage = usage,
            .source = source,
            .flags = AUDIO_FLAG_LOW_LATENCY,
            .tags = ""
    };
    ALOGD("%s(%p) MMAP attributes.usage = %d, content_type = %d, source = %d",
          __func__, this, attributes.usage, attributes.content_type, attributes.source);

    //mMmapClient类型是AudioClient
    //在open中设置，在open和startStream中使用
    mMmapClient.clientUid = request.getUserId();
    mMmapClient.clientPid = request.getProcessId();
    mMmapClient.packageName.setTo(String16(""));

    mRequestedDeviceId = deviceId = getDeviceId();

    // Fill in config
    //获取当前流的配置信息
    aaudio_format_t aaudioFormat = getFormat();
    if (aaudioFormat == AAUDIO_UNSPECIFIED || aaudioFormat == AAUDIO_FORMAT_PCM_FLOAT) {
     
        aaudioFormat = AAUDIO_FORMAT_PCM_I16;
    }
    config.format = AAudioConvert_aaudioToAndroidDataFormat(aaudioFormat);

    int32_t aaudioSampleRate = getSampleRate();
    if (aaudioSampleRate == AAUDIO_UNSPECIFIED) {
     
        aaudioSampleRate = AAUDIO_SAMPLE_RATE_DEFAULT;
    }
    config.sample_rate = aaudioSampleRate;

    int32_t aaudioSamplesPerFrame = getSamplesPerFrame();

    if (direction == AAUDIO_DIRECTION_OUTPUT) {
     
        config.channel_mask = (aaudioSamplesPerFrame == AAUDIO_UNSPECIFIED)
                              ? AUDIO_CHANNEL_OUT_STEREO
                              : audio_channel_out_mask_from_count(aaudioSamplesPerFrame);
        mHardwareTimeOffsetNanos = OUTPUT_ESTIMATED_HARDWARE_OFFSET_NANOS; // frames at DAC later

    } else if (direction == AAUDIO_DIRECTION_INPUT) {
     
        config.channel_mask =  (aaudioSamplesPerFrame == AAUDIO_UNSPECIFIED)
                               ? AUDIO_CHANNEL_IN_STEREO
                               : audio_channel_in_mask_from_count(aaudioSamplesPerFrame);
        mHardwareTimeOffsetNanos = INPUT_ESTIMATED_HARDWARE_OFFSET_NANOS; // frames at ADC earlier

    } else {
     
        ALOGE("%s() invalid direction = %d", __func__, direction);
        return AAUDIO_ERROR_ILLEGAL_ARGUMENT;
    }

    MmapStreamInterface::stream_direction_t streamDirection =
            (direction == AAUDIO_DIRECTION_OUTPUT)
            ? MmapStreamInterface::DIRECTION_OUTPUT
            : MmapStreamInterface::DIRECTION_INPUT;

    aaudio_session_id_t requestedSessionId = getSessionId();
    audio_session_t sessionId = AAudioConvert_aaudioToAndroidSessionId(requestedSessionId);

    // Open HAL stream. Set mMmapStream
    //属性和配置信息都设置完之后，就要开始打开流了
    //这里面利用MmapStreamInterface来打开HAL层的MMAP流
    //openMmapStream在MmapStreamInterface里面定义，具体实现在AudioFlinger
    status_t status = MmapStreamInterface::openMmapStream(streamDirection,
                                                          &attributes,
                                                          &config,
                                                          mMmapClient,
                                                          &deviceId,
                                                          &sessionId,
                                                          this, // callback
                                                          mMmapStream,
                                                          &mPortHandle);
    ALOGD("%s() mMapClient.uid = %d, pid = %d => portHandle = %d\n",
          __func__, mMmapClient.clientUid,  mMmapClient.clientPid, mPortHandle);
    if (status != OK) {
     
        ALOGE("%s() openMmapStream() returned status %d",  __func__, status);
        return AAUDIO_ERROR_UNAVAILABLE;
    }

    if (deviceId == AAUDIO_UNSPECIFIED) {
     
        ALOGW("%s() openMmapStream() failed to set deviceId", __func__);
    }
    setDeviceId(deviceId);

    if (sessionId == AUDIO_SESSION_ALLOCATE) {
     
        ALOGW("%s() - openMmapStream() failed to set sessionId", __func__);
    }

    aaudio_session_id_t actualSessionId =
            (requestedSessionId == AAUDIO_SESSION_ID_NONE)
            ? AAUDIO_SESSION_ID_NONE
            : (aaudio_session_id_t) sessionId;
    setSessionId(actualSessionId);
    ALOGD("%s() deviceId = %d, sessionId = %d", __func__, getDeviceId(), getSessionId());

    // Create MMAP/NOIRQ buffer.
    //创建MMAP缓存
    int32_t minSizeFrames = getBufferCapacity();
    if (minSizeFrames <= 0) {
      // zero will get rejected
        minSizeFrames = AAUDIO_BUFFER_CAPACITY_MIN;
    }
    //这个createMmapBuffer也是在AudioFlinger里面实现的
    status = mMmapStream->createMmapBuffer(minSizeFrames, &mMmapBufferinfo);
    if (status != OK) {
     
        ALOGE("%s() - createMmapBuffer() failed with status %d %s",
              __func__, status, strerror(-status));
        result = AAUDIO_ERROR_UNAVAILABLE;
        goto error;
    } else {
     
        ALOGD("%s() createMmapBuffer() returned = %d, buffer_size = %d, burst_size %d"
                      ", Sharable FD: %s",
              __func__, status,
              abs(mMmapBufferinfo.buffer_size_frames),
              mMmapBufferinfo.burst_size_frames,
              mMmapBufferinfo.buffer_size_frames < 0 ? "Yes" : "No");
    }

    setBufferCapacity(mMmapBufferinfo.buffer_size_frames);
    // The audio HAL indicates if the shared memory fd can be shared outside of audioserver
    // by returning a negative buffer size
    //音频HAL通过返回负缓冲区大小来指示共享内存fd是否可以在audioserver之外共享
    //这个可以一会分析createMmapBuffer时具体去看
    if (getBufferCapacity() < 0) {
     
        // Exclusive mode can be used by client or service.
        setBufferCapacity(-getBufferCapacity());
    } else {
     
        // Exclusive mode can only be used by the service because the FD cannot be shared.
        uid_t audioServiceUid = getuid();
        if ((mMmapClient.clientUid != audioServiceUid) &&
            getSharingMode() == AAUDIO_SHARING_MODE_EXCLUSIVE) {
     
            // Fallback is handled by caller but indicate what is possible in case
            // this is used in the future
            //回退由调用者处理，但指出在将来使用时可能发生的情况
            setSharingMode(AAUDIO_SHARING_MODE_SHARED);
            ALOGW("%s() - exclusive FD cannot be used by client", __func__);
            result = AAUDIO_ERROR_UNAVAILABLE;
            goto error;
        }
    }

    // Get information about the stream and pass it back to the caller.
    //获取有关流的信息并将其传递回调用者。
    setSamplesPerFrame((direction == AAUDIO_DIRECTION_OUTPUT)
                       ? audio_channel_count_from_out_mask(config.channel_mask)
                       : audio_channel_count_from_in_mask(config.channel_mask));

    // AAudio creates a copy of this FD and retains ownership of the copy.
    // Assume that AudioFlinger will close the original shared_memory_fd.
    //AAudio创建此FD的副本并保留副本的所有权
    //假设AudioFlinger将关闭原始共享内存
    mAudioDataFileDescriptor.reset(dup(mMmapBufferinfo.shared_memory_fd));
    if (mAudioDataFileDescriptor.get() == -1) {
     
        ALOGE("%s() - could not dup shared_memory_fd", __func__);
        result = AAUDIO_ERROR_INTERNAL;
        goto error;
    }
    mFramesPerBurst = mMmapBufferinfo.burst_size_frames;
    setFormat(AAudioConvert_androidToAAudioDataFormat(config.format));
    setSampleRate(config.sample_rate);

    // Scale up the burst size to meet the minimum equivalent in microseconds.
    // This is to avoid waking the CPU too often when the HW burst is very small
    // or at high sample rates.
    do {
     
        if (burstMicros > 0) {
       // skip first loop
            mFramesPerBurst *= 2;
        }
        burstMicros = mFramesPerBurst * static_cast<int64_t>(1000000) / getSampleRate();
    } while (burstMicros < burstMinMicros);

    ALOGD("%s() original burst = %d, minMicros = %d, to burst = %d\n",
          __func__, mMmapBufferinfo.burst_size_frames, burstMinMicros, mFramesPerBurst);

    ALOGD("%s() actual rate = %d, channels = %d"
          ", deviceId = %d, capacity = %d\n",
          __func__, getSampleRate(), getSamplesPerFrame(), deviceId, getBufferCapacity());

    return result;

error:
    close();
    return result;
}

继续看一下在AudioFlinger上面是怎样打开流和创建缓存的
xref: /frameworks/av/services/audioflinger/AudioFlinger.cpp

status_t AudioFlinger::openMmapStream(MmapStreamInterface::stream_direction_t direction,
                                      const audio_attributes_t *attr,
                                      audio_config_base_t *config,
                                      const AudioClient& client,
                                      audio_port_handle_t *deviceId,
                                      audio_session_t *sessionId,
                                      const sp<MmapStreamCallback>& callback,
                                      sp<MmapStreamInterface>& interface,
                                      audio_port_handle_t *handle)
{
     

......

    if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
     
        audio_config_t fullConfig = AUDIO_CONFIG_INITIALIZER;
        fullConfig.sample_rate = config->sample_rate;
        fullConfig.channel_mask = config->channel_mask;
        fullConfig.format = config->format;
        //注意AUDIO_OUTPUT_FLAG_MMAP_NOIRQ和AUDIO_OUTPUT_FLAG_DIRECT这两个flag
        ret = AudioSystem::getOutputForAttr(attr, &io,
                                            actualSessionId,
                                            &streamType, client.clientPid, client.clientUid,
                                            &fullConfig,
                                            (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ |
                                                    AUDIO_OUTPUT_FLAG_DIRECT),
                                            deviceId, &portId);
    } else {
     
        //注意AUDIO_INPUT_FLAG_MMAP_NOIRQ
        ret = AudioSystem::getInputForAttr(attr, &io,
                                              actualSessionId,
                                              client.clientPid,
                                              client.clientUid,
                                              client.packageName,
                                              config,
                                              AUDIO_INPUT_FLAG_MMAP_NOIRQ, deviceId, &portId);
    }
    if (ret != NO_ERROR) {
     
        return ret;
    }

    // at this stage, a MmapThread was created when openOutput() or openInput() was called by
    // audio policy manager and we can retrieve it
    //在这个阶段，当音频策略管理器调用openOutput（）或openInput（）时创建了一个MmapThread，我们可以检索它
    //这里可以根据这个io找到对应创建好的MMAPThread
    sp<MmapThread> thread = mMmapThreads.valueFor(io);
    if (thread != 0) {
     
        interface = new MmapThreadHandle(thread);
        thread->configure(attr, streamType, actualSessionId, callback, *deviceId, portId);
        *handle = portId;
        *sessionId = actualSessionId;
    } else {
     
        //没找到的话就释放掉资源
        if (direction == MmapStreamInterface::DIRECTION_OUTPUT) {
     
            AudioSystem::releaseOutput(io, streamType, actualSessionId);
        } else {
     
            AudioSystem::releaseInput(portId);
        }
        ret = NO_INIT;
    }

    ALOGV("%s done status %d portId %d", __FUNCTION__, ret, portId);

    return ret;
}

上文提到MMAPThread是在openOutput里面创建的
简单来说就是getOutputForAttr这个函数在获取到句柄的同时，也会顺便打开通路
最终调用到AudioFlinger里面的openOutput（又回来了）

status_t AudioFlinger::openOutput(audio_module_handle_t module,
                                  audio_io_handle_t *output,
                                  audio_config_t *config,
                                  audio_devices_t *devices,
                                  const String8& address,
                                  uint32_t *latencyMs,
                                  audio_output_flags_t flags)
{
     
    ALOGI("openOutput() this %p, module %d Device %#x, SamplingRate %d, Format %#08x, "
              "Channels %#x, flags %#x",
              this, module,
              (devices != NULL) ? *devices : 0,
              config->sample_rate,
              config->format,
              config->channel_mask,
              flags);

    if (devices == NULL || *devices == AUDIO_DEVICE_NONE) {
     
        return BAD_VALUE;
    }

    Mutex::Autolock _l(mLock);

    sp<ThreadBase> thread = openOutput_l(module, output, config, *devices, address, flags);
    if (thread != 0) {
     
        //看到这个flag了---AUDIO_OUTPUT_FLAG_MMAP_NOIRQ
        if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {
     
            ......
            }
        } else {
     
            //最终拿到已经创建好的线程
            //但是是在哪创建的呢
            MmapThread *mmapThread = (MmapThread *)thread.get();
            mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);
        }
        return NO_ERROR;
    }

    return NO_INIT;
}

MmapThread线程是在AudioFlinger里面的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 devices,
                                                            const String8& address,
                                                            audio_output_flags_t flags)
{
     
    AudioHwDevice *outHwDev = findSuitableHwDev_l(module, devices);
    if (outHwDev == NULL) {
     
        return 0;
    }
    
    ......

    AudioStreamOut *outputStream = NULL;
    status_t status = outHwDev->openOutputStream(
            &outputStream,
            *output,
            devices,
            flags,
            config,
            address.string());

    mHardwareStatus = AUDIO_HW_IDLE;

    if (status == NO_ERROR) {
     
        //又看到这个flag了
        //根据参数在这创建的MmapPlaybackThread
        if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {
     
            sp<MmapPlaybackThread> thread =
                    new MmapPlaybackThread(this, *output, outHwDev, outputStream,
                                          devices, AUDIO_DEVICE_NONE, mSystemReady);
            //加入到线程组里面
            mMmapThreads.add(*output, thread);
            ALOGV("openOutput_l() created mmap playback thread: ID %d thread %p",
                  *output, thread.get());
            return thread;
        } else {
     
            ......
        }
    }

    return 0;
}

打开输出流这里面又调用到了AudioHwDevice的openOutputStream方法
xref: /frameworks/av/services/audioflinger/AudioHwDevice.cpp

status_t AudioHwDevice::openOutputStream(
        AudioStreamOut **ppStreamOut,
        audio_io_handle_t handle,
        audio_devices_t devices,
        audio_output_flags_t flags,
        struct audio_config *config,
        const char *address)
{
     

    struct audio_config originalConfig = *config;
    AudioStreamOut *outputStream = new AudioStreamOut(this, flags);
    
    //调到了hal层，继续打开通路
    status_t status = outputStream->open(handle, devices, config, address);

    ......

    *ppStreamOut = outputStream;
    return status;
}

整个流程大概分析了一遍
重点记住这个flag：
AUDIO_OUTPUT_FLAG_MMAP_NOIRQ
AUDIO_INPUT_FLAG_MMAP_NOIRQ
在整个打开通路的流程中起着重要的作用

上述只分析了独占模式下的情况，共享模式和这个类似，读者可以根据时序图自行分析
AAudioService的其他方法，将在后续章节发出

---

总结

以上对AAudioService这个服务以及它的OpenStream方法做了详细的分析

（1）AAudio并没有走AudioTrack和AudioRecod
（2）AAudio最终还是要通过AudioFlinger打开音频通路和创建播放线程
（3）AAudio核心原理是通过内存映射来减小内存数据拷贝次数，增加音频传输效率，减小延迟
（4）AAudioServiceStreamMMAP创建流之后得到了AAudioServiceEndpointMMAP类型的对象，后续对音频流的操作都是 通过操作这个对象来实现的