mtk android 4.4 audio framework 代码分析(未完成)_综合

mtk android 4.4 audio framework 代码分析(未完成)，有需要的朋友可以参考下。

mtk android 4.4 audio framework 代码分析(未完成)

2/28/2015 3:01:24 PM

关于 audio_policy.conf 文件

这个文件 mediatek/config/$project 下，在 audiomtkpolicymanager.cpp 中解析，
解析出如下信息：

 1）  ATTACHED_OUTPUT_DEVICES_TAG "attached_output_devices" ，对应 类定义中的变量 mAttachedOutputDevices2 ） #define DEFAULT_OUTPUT_DEVICE_TAG "default_output_device"

对应类定义中的 mDefaultOutputDevice

#define ATTACHED_INPUT_DEVICES_TAG "attached_input_devices"

对应类定义中的 mAvailableInputDevices

    mHasA2dp = true; 根据文件解析出是否有此MODULE。mHasUsb = true; 根据文件接触出是否有此MODULE。mHasRemoteSubmix = true; 根据文件接触出是否有此MODULE。

3）
最重要的解析出 mHwModules，而这个变量的定义在audiomtkpolicymanager.h 中，Vector

APS构造函数分析：

上面关于文件解析的东西其实也属于本节的内容，不过还是单独出去了。

-》mpClientInterface = clientInterface; 就是APS
-》  AudioMTKPolicyManager::LoadCustomVolume
-》GetVolumeVer1ParamFromNV 从NVRAM里读取参数，这个暂且不表。
-》initializeVolumeCurves();  // 初始化VOLUME曲线，SETVOLUME时会用到，以后分析。
-》if (loadAudioPolicyConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE) != NO_ERROR)

上面已经分析了，解析配置文件。

-》mHwModules[i]->mHandle = mpClientInterface->loadHwModule(mHwModules[i]->mName);
mHandle 是 audio_module_handle_t类型，实际上是 AF中成员变量DefaultKeyedVector

AudioMTKPolicyManager::setOutputDevice 分析

原型：
uint32_t AudioMTKPolicyManager::setOutputDevice(audio_io_handle_t output,
audio_devices_t device,
bool force,
int delayMs)

-》

AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output); 根据传入参数取得 outputDesc

-》

if (outputDesc->isDuplicated()) {  // 蓝牙，暂且不分析muteWaitMs = setOutputDevice(outputDesc->mOutput1->mId, device, force, delayMs);muteWaitMs += setOutputDevice(outputDesc->mOutput2->mId, device, force, delayMs);return muteWaitMs;
}

-》

if (device != AUDIO_DEVICE_NONE) {outputDesc->mDevice = device;
}   // 设置 outputDesc  route to  传入的 device. 软件层面上的。

-》

muteWaitMs = checkDeviceMuteStrategies(outputDesc, prevDevice, delayMs);

-》

param.addInt(String8(AudioParameter::keyRouting), (int)device);  设置keyroute 的PARA,

-》

mpClientInterface->setParameters(output, param.toString(), delayMs);  APS cmd thread 切换。

-》 // update stream volumes according to new device

applyStreamVolumes(output, device, delayMs);  
分析见下面。

设备路由：

mpClientInterface->setParameters(output, param.toString(), delayMs);  APS cmd thread 切换。
定义 void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,const char *keyValuePairs,int delayMs)
{mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,delayMs);
}-》 AudioCommand *command = new AudioCommand();
-》 insertCommand_l(command, delayMs);
-》 AudioCommandThread::threadLoop()
-》case SET_PARAMETERS:  AudioSystem::setParameters
-》 af->setParameters
-》 thread = checkPlaybackThread_l(ioHandle); 找到 相应的 thread
-》 thread->setParameters(keyValuePairs);  
-》 ThreadBase::setParameters(const String8& keyValuePairs)
-》 mNewParameters.add(keyValuePairs);  
Vector<String8>         mNewParameters 是 ThreadBase的成员变量。
-》 PlaybackThread::threadLoop()
-》 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,keyValuePair.string());

mOutput 是AudioStreamOut 类型：

struct AudioStreamOut {AudioHwDevice* const audioHwDev;audio_stream_out_t* const stream;audio_hw_device_t* hwDev() const { return audioHwDev->hwDevice(); }AudioStreamOut(AudioHwDevice *dev, audio_stream_out_t *out) :audioHwDev(dev), stream(out) {}
};

-》 out->stream.common.set_parameters = out_set_parameters; HAL层

-》 status_t AudioMTKStreamOut::setParameters(const String8 &keyValuePairs)

{
AudioParameter param = AudioParameter(keyValuePairs);
String8 keyRouting = String8(AudioParameter::keyRouting);
status_t status = NO_ERROR;
int devices = 0;
ALOGD("setParameters() %s", keyValuePairs.string());
if (param.getInt(keyRouting, devices) == NO_ERROR) {param.remove(keyRouting);dokeyRouting(devices);mAudioResourceManager->doSetMode();
}
if (param.size()) {status = BAD_VALUE;
}
return status;
}

-》 AudioMTKStreamOut::dokeyRouting(uint32_t new_device)

-》 mAudioResourceManager->SelectOutputDevice(new_device);

-》 AudioResourceManager::SelectOutputDevice(uint32_t new_device)

 AudioResourceManager::SelectOutputDevice 分析pre_device = mDlOutputDevice;

-》 StopOutputDevice(); // 关掉 mDlOutputDevice，

-》 mDlOutputDevice = new_device; 设置NEW device。

-》 AudioResourceManager::StartOutputDevice()

AudioResourceManager::StartOutputDevice() 分析

定义：

switch (mAudioMode) {case AUDIO_MODE_NORMAL:case AUDIO_MODE_RINGTONE: {TurnonAudioDevice(mDlOutputDevice);break;}case AUDIO_MODE_IN_CALL:case AUDIO_MODE_IN_CALL_2: {TurnonAudioDeviceIncall(mDlOutputDevice);break;}case AUDIO_MODE_IN_COMMUNICATION: {TurnonAudioDevice(mDlOutputDevice);break;}
}

-》 AudioResourceManager::TurnonAudioDevice(unsigned int mDlOutputDevice)

-》 mAudioAnalogInstance->AnalogOpen(AudioAnalogType::DEVICE_OUT_EARPIECER,
AudioAnalogType::DEVICE_PLATFORM_MACHINE); 打开对应的设备。

-》 AudioAnalogControl::AnalogOpen
定义：

// analog open power , need to open by mux setting
status_t AudioAnalogControl::AnalogOpen(AudioAnalogType::DEVICE_TYPE DeviceType,    AudioAnalogType::DEVICE_TYPE_SETTING Type_setting)
{
ALOGD("AnalogOpen DeviceType = %s", kAudioAnalogDeviceTypeName[DeviceType]);
CheckDevicePolicy((uint32*)&DeviceType,AudioAnalogType::AUDIOANALOG_DEVICE);
mBlockAttribute[DeviceType].mEnable = true;
mAudioPlatformDevice->AnalogOpen(DeviceType);  直接操作KERNEL 接口，寄存器。
mAudioMachineDevice->AnalogOpen(DeviceType);
return NO_ERROR;
}

音量调节 AudioMTKPolicyManager::applyStreamVolumes 分析

void applyStreamVolumes(audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false);   //  注意调用此传入的参数。

-》
for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
checkAndSetVolume(stream,
mStreams[stream].getVolumeIndex(device),
output,
device,
delayMs,
force);
}

-》传入的参数 StreamDescriptor mStreams[AudioSystem::NUM_STREAM_TYPES]; // stream descriptors for volume control 定义，实际上类似于一个二维数组，STREAM是第一维， DEVICE是第二维。上述代码实际上是取出音量的index(int).

class StreamDescriptor{public:StreamDescriptor();int getVolumeIndex(audio_devices_t device);void dump(int fd);int mIndexMin;      // min volume indexint mIndexMax;      // max volume indexKeyedVector<audio_devices_t, int> mIndexCur;   // current volume index per devicebool mCanBeMuted;   // true is the stream can be mutedconst VolumeCurvePoint *mVolumeCurve[DEVICE_CATEGORY_CNT];#ifdef MTK_AUDIOfloat mIndexRange;#endif};

checkAndSetVolume 分析

AudioMTKPolicyManager::checkAndSetVolume
定义：

status_t checkAndSetVolume(int stream, int index, audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false); //  注意 后面2个参数。

-》

if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) { ALOGV("checkAndSetVolume() stream %d muted count %d",stream, mOutputs.valueFor(output)->mMuteCount[stream]);return NO_ERROR;
}  do not change actual stream volume if the stream is muted

-》

 // do not change in call volume if bluetooth is connected and vice versa
if ((stream == AudioSystem::VOICE_CALL && mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||(stream == AudioSystem::BLUETOOTH_SCO && mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO)) {ALOGD("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",stream, mForceUse[AudioSystem::FOR_COMMUNICATION]);return INVALID_OPERATION;
}

-》

float volume = computeVolume(stream, index, output, device);  // 计算音量。 后面详细分析、

-》

 //for VT notify tone when incoming call. it's volume will be adusted in hardware.if((stream == AudioSystem::VOICE_CALL ||stream == AudioSystem::BLUETOOTH_SCO) && mOutputs.valueFor(output)->mRefCount[stream]!=0 && mPhoneState==AudioSystem::MODE_IN_CALL){volume =1.0;}   处理特列 MODE_IN_CALL

-》

 // ALPS00554824 KH: If notifiaction is exist, FM should be muteif ((stream == AudioSystem::FM) &&(mOutputs.valueFor(output)->mRefCount[AudioSystem::NOTIFICATION]|| mOutputs.valueFor(output)->mRefCount[AudioSystem::RING]|| mOutputs.valueFor(output)->mRefCount[AudioSystem::ALARM])){volume =0.0;}

-》

if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||force)    the float value returned by computeVolume() changed
// - the force flag is set ，两者有一个条件满足则可以 调节音量。

-》

mOutputs.valueFor(output)->mCurVolume[stream] = volume;   
float mCurVolume[AudioSystem::NUM_STREAM_TYPES];   // current stream volume，更新软件音量。

-》

mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);   //aps  set volume

-》

 int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delayMs)
{
return (int)mAudioCommandThread->volumeCommand(stream, volume,output, delayMs);
}

-》

 AudioCommandThread::volumeCommand

-》

AudioCommand *command = new AudioCommand();

-》

insertCommand_l(command, delayMs);

-》

 mAudioCommands.insertAt(command, i + 1);   加入到mAudioCommands的  CMD容器中。

-》

 AudioCommandThread::threadLoop
while (!mAudioCommands.isEmpty()) {nsecs_t curTime = systemTime();// commands are sorted by increasing time stamp: execute them from index 0 and upif (mAudioCommands[0]->mTime <= curTime) {
// 当mAudioCommands 不为空，时间来到，

-》

CASE  SET_VOLUME: {VolumeData *data = (VolumeData *)command->mParam;ALOGV("AudioCommandThread() processing set volume stream %d, \volume %f, output %d", data->mStream, data->mVolume, data->mIO);command->mStatus = AudioSystem::setStreamVolume(data->mStream,                                                                   data->mVolume,data->mIO);   //

-》

af->setStreamVolume(stream, value, output);   下面分析### AudioFlinger::setStreamVolume 分析 ###
status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,audio_io_handle_t output)   定义

-》

thread = checkPlaybackThread_l(output);

-》

 mStreamTypes[stream].volume = value;   设置软件音量 
stream_type_t  mStreamTypes[AUDIO_STREAM_CNT + 1];  AF中音量表示方法。

-》

thread->setStreamVolume(stream, value);   后面分析

-》

 if(stream == AUDIO_STREAM_FM)
{MTK_ALOG_D("setStreamVolume FM  value = %f",value);
#if defined(MT5192_FM) || defined(MT5193_FM)int FmVolume = (AudioSystem::logToLinear(value));char Volume[30];sprintf(Volume,"SetFmVolume=%d",FmVolume);String8 Key = String8(Volume);
#elseint FmVolume = (AudioSystem::logToLinear(value)>>4);char Volume[30];sprintf(Volume,"SetFmVolume=%d",FmVolume);String8 Key = String8(Volume);
#endifaudio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();dev->set_parameters (dev,Key);
}   如果是stream 是FM， 则直接dev->set_parameters (dev,Key); 设置硬件VOLUME.### PlaybackThread::setStreamVolume 分析 ###
struct  stream_type_t {   stream_type_t():   volume(1.0f),mute(false){}float       volume;bool        mute;
};  // AF中  和  PLAYBACKTHREAD 中都有个这样的。
定义 void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
{Mutex::Autolock _l(mLock);mStreamTypes[stream].volume = value;
}

插入耳机路由切换过程 WiredAccessoryManager ###

构造函数中 mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
-》
mObserver = new WiredAccessoryObserver();
-》
init 中 public String getSwitchStatePath() {
return String.format(“/sys/class/switch/%s/state”, mDevName);
}
-》
mAudioManager.setWiredDeviceConnectionState(device, state, headsetName);
-》
AudioService中 public void setWiredDeviceConnectionState(int device, int state, String name) {
synchronized (mConnectedDevices) {
int delay = checkSendBecomingNoisyIntent(device, state);
queueMsgUnderWakeLock(mAudioHandler,
MSG_SET_WIRED_DEVICE_CONNECTION_STATE,
device,
state,
name,
delay);
}
}
-》
checkSendBecomingNoisyIntent 中
sendMsg(mAudioHandler ， MSG_BROADCAST_AUDIO_BECOMING_NOISY,
SENDMSG_REPLACE,
0,
0,
null,
0);
delay = 1000;
Senmsg在handler中处理

sendBroadcastToAll(new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY));
这个广播哪些地方有处理，举例子：MUSIC应用中public void onReceive(Context context, Intent intent) {String intentAction = intent.getAction();MusicLogUtils.d("MediaButtonIntentReceiver", "intentAction " + intentAction);if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intentAction)) {

-》
i.setAction(MediaPlaybackService.SERVICECMD);
i.putExtra(MediaPlaybackService.CMDNAME, MediaPlaybackService.CMDPAUSE);
context.startService(i);
-》
在 mediaplayerservice 中处理
else if (CMDPAUSE.equals(cmd) || PAUSE_ACTION.equals(action)
|| AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(action)) {
pause();
mPausedByTransientLossOfFocus = false;
}
-》 audioservice 中

case MSG_SET_WIRED_DEVICE_CONNECTION_STATE:onSetWiredDeviceConnectionState(msg.arg1, msg.arg2, (String)msg.obj);

-》
private void onSetWiredDeviceConnectionState(int device, int state, String name)
{
synchronized (mConnectedDevices) {
Log.d(TAG,”onSetWiredDeviceConnectionState:” + “device:” + device + “,state:” + state);
if ((state == 0) && ((device == AudioSystem.DEVICE_OUT_WIRED_HEADSET) ||(device == AudioSystem.DEVICE_OUT_WIRED_HEADPHONE))) { // 耳机
/// M: Change for sound output from device when a2dp conneted @ {
//setBluetoothA2dpOnInt(true); AudioSystem.setForceUse(AudioSystem.FOR_MEDIA,AudioSystem.FORCE_NONE);
///@}
}
boolean isUsb = ((device & AudioSystem.DEVICE_OUT_ALL_USB) != 0);
handleDeviceConnection((state == 1), device, (isUsb ? name : “”));
if (state != 0) {
if ((device == AudioSystem.DEVICE_OUT_WIRED_HEADSET) ||
(device == AudioSystem.DEVICE_OUT_WIRED_HEADPHONE)) {
setBluetoothA2dpOnInt(false);
}
if ((device & mSafeMediaVolumeDevices) != 0) {
sendMsg(mAudioHandler,
MSG_CHECK_MUSIC_ACTIVE,
SENDMSG_REPLACE,
0,
0,
null,
MUSIC_ACTIVE_POLL_PERIOD_MS);
}
}
if (!isUsb) {
sendDeviceConnectionIntent(device, state, name);
}
}
}

AudioSystem.setForceUse 分析 handleDeviceConnection（audioservice）分析

boolean isUsb = ((device & AudioSystem.DEVICE_OUT_ALL_USB) != 0);
handleDeviceConnection((state == 1), device, (isUsb ? name : “”));
下面是定义：

private boolean handleDeviceConnection(boolean connected, int device, String params) {synchronized (mConnectedDevices) {boolean isConnected = (mConnectedDevices.containsKey(device) &&(params.isEmpty() || mConnectedDevices.get(device).equals(params)));Log.d(TAG,"handleDeviceConnection:isConnected" + isConnected);if (isConnected && !connected) { 、、 拔出AudioSystem.setDeviceConnectionState(device,  设置状态AudioSystem.DEVICE_STATE_UNAVAILABLE,mConnectedDevices.get(device));Log.d(TAG,"handleDeviceConnection remove:" + "connected:" + connected + ",device:" + device);mConnectedDevices.remove(device);  移除设备。return true;} else if (!isConnected && connected) {AudioSystem.setDeviceConnectionState(device,AudioSystem.DEVICE_STATE_AVAILABLE,params);Log.d(TAG,"handleDeviceConnection connect:" + "connected:" + connected + ",device:" + device);mConnectedDevices.put(new Integer(device), params);return true;}}return false;
}

-》

AudioSystem::setDeviceConnectionState

-》

aps->setDeviceConnectionState(

-》

AudioMTKPolicyManager::setDeviceConnectionState(audio_devices_t device,
AudioSystem::device_connection_state state,const char *device_address)

-》

case AudioSystem::DEVICE_STATE_AVAILABLE:
if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {return INVALID_OPERATION;
}ALOGD("setDeviceConnectionState() checkOutputsForDevice() returned %d outputs",outputs.size());// register new device as availablemAvailableOutputDevices = (audio_devices_t)(mAvailableOutputDevices | device);     输出设备。checkOutputForAllStrategies();  更新strategy
if ((state == AudioSystem::DEVICE_STATE_UNAVAILABLE) ||(mOutputs.valueFor(outputs[i])->mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) {closeOutput(outputs[i]);   关掉 output} updateDevicesAndOutputs();  
for (size_t i = 0; i < mOutputs.size(); i++) {// do not force device change on duplicated output because if device is 0, it will// also force a device 0 for the two outputs it is duplicated to which may override// a valid device selection on those outputs.setOutputDevice(mOutputs.keyAt(i),getNewDevice(mOutputs.keyAt(i), true /*fromCache*/),!mOutputs.valueAt(i)->isDuplicated(),0);}### AudioMTKPolicyManager::checkOutputForAllStrategies() 分析 ###

-》

调用  AudioMTKPolicyManager::checkOutputForStrategy(routing_strategy strategy)

-》

audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/);audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/);SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs);
SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs);

-》

if (desc->strategyRefCount(strategy) != 0) {  //   #ifdef MTK_AUDIO    //ALPS00446176 .ex: Speaker->Speaker,Don't move track and mute. Only change to dstOutputs[0]if(dstOutputs[0]!=srcOutputs[i])  如果现在的dstOutputs不在 srcOutputs中{setStrategyMute(strategy, true, srcOutputs[i]); // 立即MUTE setStrategyMute(strategy, false, srcOutputs[i], MUTE_TIME_MS, newDevice);  // 2秒后unmute  newDevice}#elsesetStrategyMute(strategy, true, srcOutputs[i]);setStrategyMute(strategy, false, srcOutputs[i], MUTE_TIME_MS, newDevice);#endif}

-》

AudioMTKPolicyManager::setStrategyMute

-》

setStreamMute(stream, on, output, delayMs, device);

-》

AudioMTKPolicyManager::setStreamMute(int stream,bool on,audio_io_handle_t output,int delayMs,audio_devices_t device)

-》

if (on) { //  mute onif (outputDesc->mMuteCount[stream] == 0) {if (streamDesc.mCanBeMuted &&((stream != AudioSystem::ENFORCED_AUDIBLE) ||(mForceUse[AudioSystem::FOR_SYSTEM] == AudioSystem::FORCE_NONE))) {checkAndSetVolume(stream, 0, output, device, delayMs);}}// increment mMuteCount after calling checkAndSetVolume() so that volume change is not ignoredoutputDesc->mMuteCount[stream]++;
}
checkAndSetVolume // 上面已经分析过了，最后会设置音量到 af对应的threads
接上面函数继续分析

-》

// Move tracks associated to this strategy from previous output to new outputfor (int i = 0; i < (int)AudioSystem::NUM_STREAM_TYPES; i++) {if (getStrategy((AudioSystem::stream_type)i) == strategy) {//FIXME see fixme on name changempClientInterface->setStreamOutput((AudioSystem::stream_type)i,dstOutputs[0] /* ignored */);}}

-》

status_t AudioPolicyCompatClient::setStreamOutput(AudioSystem::stream_type stream,audio_io_handle_t output)
{return mServiceOps->set_stream_output(mService, (audio_stream_type_t)stream,output);
}

-》

aps： set_stream_output

-》

af->setStreamOutput

-》

status_t AudioFlinger::setStreamOutput(audio_stream_type_t stream, audio_io_handle_t output)
{Mutex::Autolock _l(mLock);ALOGV("setStreamOutput() stream %d to output %d", stream, output);for (size_t i = 0; i < mPlaybackThreads.size(); i++) {PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();thread->invalidateTracks(stream);}return NO_ERROR;
}

-》

PlaybackThread::cacheParameters_l()

-》

PlaybackThread：  t->mCblk->cv.signal(); 发信号， 哪里在等还没找到。uint32_t mRefCount[AudioSystem::NUM_STREAM_TYPES]; // number of streams of each type using this outputDefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor *> mPreviousOutputs;

Audioservice中重要变量：

private final HashMap <Integer, String> mConnectedDevices = new HashMap <Integer, String>();

AudioTrack 跟踪

AudioTrack.java
blic AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat,int bufferSizeInBytes, int mode, int sessionId)

-》
int initResult = native_setup(new WeakReference(this),
mStreamType, mSampleRate, mChannels, mAudioFormat,
mNativeBufferSizeInBytes, mDataLoadMode, session);

-》

android_media_AudioTrack_native_setup(JNIEnv *env, jobject thiz, jobject weak_this,jint streamType, jint sampleRateInHertz, jint javaChannelMask,jint audioFormat, jint buffSizeInBytes, jint memoryMode, jintArray jSession)
sp<AudioTrack> lpTrack = new AudioTrack();

-》

## AudioFlinger::openOutput  分析 ##
DefaultKeyedVector< audio_io_handle_t, sp<PlaybackThread> >  mPlaybackThreads;
在 AudioFlinger::openOutput  中 返回的就是这个audio_io_handle_t  KEY值。 AudioFlinger::openOutput

outHwDev = findSuitableHwDev_l(module, *pDevices); // 找到  AudioHwDevice, 对应HAL 下的一个设备。

->
status = hwDevHal->open_output_stream(hwDevHal,
id,
*pDevices,
(audio_output_flags_t)flags,
&config,
&outStream);
outStream 是在HAL层分配的，然后返回到AF中。

-》

AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream);  // 用上述2个NEW一个 AudioStreamOut。

if ((flags & AUDIO_OUTPUT_FLAG_DIRECT) ||(config.format != AUDIO_FORMAT_PCM_16_BIT) ||(config.channel_mask != AUDIO_CHANNEL_OUT_STEREO)) {thread = new DirectOutputThread(this, output, id, *pDevices);ALOGV("openOutput() created direct output: ID %d thread %p", id, thread);} else {thread = new MixerThread(this, output, id, *pDevices);ALOGV("openOutput() created mixer output: ID %d thread %p", id, thread);
附录LOG：（开机过程中）
Line 2397: 01-01 03:59:20.971207   211   211 D AudioFlinger: openOutput(), module 1 Device 2, SamplingRate 44100, Format 0x000003, Channels 3, flags 2
Line 2398: 01-01 03:59:20.971246   211   211 D AudioFlinger: openOutput(), offloadInfo 0x0 version 0xffffffff
Line 2399: 01-01 03:59:20.971291   211   211 D AudioALSAStreamManager: +openOutputStream()
Line 2888: 01-01 03:59:21.028671   211   211 D AudioALSAStreamManager: -openOutputStream(), out = 0xb7ba8250, status = 0x0, mStreamOutVector.size() = 1
Line 2889: 01-01 03:59:21.028791   211   211 D AudioFlinger: openOutput() openOutputStream returned output 0xb7ba81e0, SamplingRate 44100, Format 0x000003, Channels 3, status 0, flags 2
Line 2889: 01-01 03:59:21.028791   211   211 D AudioFlinger: openOutput() openOutputStream returned output 0xb7ba81e0, SamplingRate 44100, Format 0x000003, Channels 3, status 0, flags 2
Line 2905: 01-01 03:59:21.048650   211   211 D AudioFlinger: openOutput() created mixer output: ID 2 thread 0xb4b26008
（在 AudioFlinger 构造函数中初始化了 mNextUniqueId(1) ）

-》

AudioTrack::AudioTrack(audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,int frameCount,audio_output_flags_t flags,callback_t cbf,void* user,int notificationFrames,int sessionId,transfer_type transferType,const audio_offload_info_t *offloadInfo,int uid): mStatus(NO_INIT),mIsTimed(false),mPreviousPriority(ANDROID_PRIORITY_NORMAL),mPreviousSchedulingGroup(SP_DEFAULT),mPausedPosition(0)
{mStatus = set(streamType, sampleRate, format, channelMask,frameCount, flags, cbf, user, notificationFrames,0 /*sharedBuffer*/, false /*threadCanCallJava*/, sessionId, transferType,offloadInfo, uid);
}}mPlaybackThreads.add(id, thread);

-》

audio_io_handle_t output = AudioSystem::getOutput(streamType,sampleRate, format, channelMask,flags,offloadInfo);
if (cbf != NULL) {mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);mAudioTrackThread->run("AudioTrack", ANDROID_PRIORITY_AUDIO, 0 /*stack*/);}// create the IAudioTrackstatus_t status = createTrack_l(streamType,sampleRate,format,frameCount,flags,sharedBuffer,output,0 /*epoch*/);

-》

sp<IAudioTrack> track = audioFlinger->createTrack(streamType,sampleRate,// AudioFlinger only sees 16-bit PCMformat == AUDIO_FORMAT_PCM_8_BIT ?AUDIO_FORMAT_PCM_16_BIT : format,mChannelMask,frameCount,&trackFlags,sharedBuffer,output,tid,&mSessionId,mName,mClientUid,&status);

-》

track = thread->createTrack_l(client, streamType, sampleRate, format,channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, clientUid, &lStatus);

-》

// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(const sp<AudioFlinger::Client>& client,audio_stream_type_t streamType,uint32_t sampleRate,audio_format_t format,audio_channel_mask_t channelMask,size_t frameCount,const sp<IMemory>& sharedBuffer,int sessionId,IAudioFlinger::track_flags_t *flags,pid_t tid,int uid,status_t *status)
{
sp<Track> track;
status_t lStatus;bool isTimed = (*flags & IAudioFlinger::TRACK_TIMED) != 0;// client expresses a preference for FAST, but we get the final say
if (*flags & IAudioFlinger::TRACK_FAST) {if (// not timed(!isTimed) &&// either of these use cases:(// use case 1: shared buffer with any frame count((sharedBuffer != 0)) ||// use case 2: callback handler and frame count is default or at least as large as HAL((tid != -1) &&((frameCount == 0) ||(frameCount >= mFrameCount)))) &&// PCM dataaudio_is_linear_pcm(format) &&// mono or stereo( (channelMask == AUDIO_CHANNEL_OUT_MONO) ||(channelMask == AUDIO_CHANNEL_OUT_STEREO) ) &&
#ifndef FAST_TRACKS_AT_NON_NATIVE_SAMPLE_RATE// hardware sample rate(sampleRate == mSampleRate) &&
#endif// normal mixer has an associated fast mixerhasFastMixer() &&// there are sufficient fast track slots available(mFastTrackAvailMask != 0)// FIXME test that MixerThread for this fast track has a capable output HAL// FIXME add a permission test also?) {// if frameCount not specified, then it defaults to fast mixer (HAL) frame countif (frameCount == 0) {frameCount = mFrameCount * kFastTrackMultiplier;}ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%d mFrameCount=%d",frameCount, mFrameCount);} else {ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: isTimed=%d sharedBuffer=%p frameCount=%d ""mFrameCount=%d format=%d isLinear=%d channelMask=%#x sampleRate=%u mSampleRate=%u ""hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",isTimed, sharedBuffer.get(), frameCount, mFrameCount, format,audio_is_linear_pcm(format),channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);*flags &= ~IAudioFlinger::TRACK_FAST;// For compatibility with AudioTrack calculation, buffer depth is forced// to be at least 2 x the normal mixer frame count and cover audio hardware latency.// This is probably too conservative, but legacy application code may depend on it.// If you change this calculation, also review the start threshold which is related.uint32_t latencyMs = mOutput->stream->get_latency(mOutput->stream);uint32_t minBufCount = latencyMs / ((1000 * mNormalFrameCount) / mSampleRate);if (minBufCount < 2) {minBufCount = 2;}#ifdef MTK_AUDIOsize_t minFrameCount = (mFrameCount*sampleRate*minBufCount)/mSampleRate;
#elsesize_t minFrameCount = mNormalFrameCount * minBufCount;
#endifif (frameCount < minFrameCount) {frameCount = minFrameCount;}}
}if (mType == DIRECT) {if ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) {if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {ALOGE("createTrack_l() Bad parameter: sampleRate %u format %d, channelMask 0x%08x ""for output %p with format %d",sampleRate, format, channelMask, mOutput, mFormat);lStatus = BAD_VALUE;goto Exit;}}
} else if (mType == OFFLOAD) {if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {ALOGE("createTrack_l() Bad parameter: sampleRate %d format %d, channelMask 0x%08x \"""for output %p with format %d",sampleRate, format, channelMask, mOutput, mFormat);lStatus = BAD_VALUE;goto Exit;}
} else {if ((format & AUDIO_FORMAT_MAIN_MASK) != AUDIO_FORMAT_PCM) {ALOGE("createTrack_l() Bad parameter: format %d \"""for output %p with format %d",format, mOutput, mFormat);lStatus = BAD_VALUE;goto Exit;}// Resampler implementation limits input sampling rate to 2 x output sampling rate.if (sampleRate > mSampleRate*2) {ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
#ifndef MTK_AUDIOlStatus = BAD_VALUE;goto Exit;
#endif}
}lStatus = initCheck();
if (lStatus != NO_ERROR) {ALOGE("Audio driver not initialized.");goto  Exit;
}{ // scope for mLockMutex::Autolock _l(mLock);// all tracks in same audio session must share the same routing strategy otherwise// conflicts will happen when tracks are moved from one output to another by audio policy// manageruint32_t strategy = AudioSystem::getStrategyForStream(streamType);for (size_t i = 0; i < mTracks.size(); ++i) {sp<Track> t = mTracks[i];if (t != 0 && !t->isOutputTrack()) {uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());if (sessionId == t->sessionId() && strategy != actual) {ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",strategy, actual);lStatus = BAD_VALUE;goto Exit;}}}if (!isTimed) {track = new Track(this, client, streamType, sampleRate, format,channelMask, frameCount, sharedBuffer, sessionId, uid, *flags);} else {track = TimedTrack::create(this, client, streamType, sampleRate, format,channelMask, frameCount, sharedBuffer, sessionId, uid);}if (track == 0 || track->getCblk() == NULL || track->name() < 0) {lStatus = NO_MEMORY;// track must be cleared from the caller as the caller has the AF lockgoto Exit;}mTracks.add(track);ALOGD("%s, mTracks.add(), track 0x%x, this 0x%x", __FUNCTION__, track.get(), this);sp<EffectChain> chain = getEffectChain_l(sessionId);if (chain != 0) {ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());track->setMainBuffer(chain->inBuffer());chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));chain->incTrackCnt();}if ((*flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {pid_t callingPid = IPCThreadState::self()->getCallingPid();// we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,// so ask activity manager to do this on our behalfsendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp);}
}lStatus = NO_ERROR;Exit:
if (status) {*status = lStatus;
}
return track;
}

-》
uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
track = new Track(this, client, streamType, sampleRate, format,
channelMask, frameCount, sharedBuffer, sessionId, uid, *flags);
-》
AudioFlinger::PlaybackThread::Track::Track
－》
AudioTrackServerProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,
size_t frameSize, bool clientInServer = false)
: ServerProxy(cblk, buffers, frameCount, frameSize, true /isOut/, clientInServer) { }
－》

ServerProxy::ServerProxy(audio_track_cblk_t* cblk, void *buffers, size_t frameCount,size_t frameSize, bool isOut, bool clientInServer)
: Proxy(cblk, buffers, frameCount, frameSize, isOut, clientInServer),mAvailToClient(0), mFlush(0)
{
}

然后根据这个 streamout 和ID, NEW threads. 然后ADD 到 AF中的 mPlaybackThreads。
-》hwDevHal->set_mode(hwDevHal, mMode); // 大概是设置MODE, NORMAL , CALL MODE? 条件是 (mPrimaryHardwareDev == NULL) ，只有第一次AudioFlinger::openOutput 时会设置模式。

HAL 层 open_output_stream

Audio_hw_hal.cpp 中关于
legacy_adev_open 中将
ladev->device.open_output_stream = adev_open_output_stream;
-》 adev_open_output_stream

-》
static int adev_open_output_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
struct audio_config *config,
struct audio_stream_out **stream_out)
{
struct legacy_audio_device *ladev = to_ladev(dev);
status_t status;
struct legacy_stream_out *out;
int ret;

    out = (struct legacy_stream_out *)calloc(1, sizeof(*out));  分配内存，然后由下面设备填充。if (!out)return -ENOMEM;// 打开设备，填充out->legacy_out = ladev->hwif->openOutputStreamWithFlag(devices, (int *) &config->format,&config->channel_mask,&config->sample_rate, &status, flags);if (!out->legacy_out) {ret = status;goto err_open;}out->stream.common.get_sample_rate = out_get_sample_rate;out->stream.common.set_sample_rate = out_set_sample_rate;out->stream.common.get_buffer_size = out_get_buffer_size;out->stream.common.get_channels = out_get_channels;out->stream.common.get_format = out_get_format;out->stream.common.set_format = out_set_format;out->stream.common.standby = out_standby;out->stream.common.dump = out_dump;out->stream.common.set_parameters = out_set_parameters;out->stream.common.get_parameters = out_get_parameters;out->stream.common.add_audio_effect = out_add_audio_effect;out->stream.common.remove_audio_effect = out_remove_audio_effect;out->stream.get_latency = out_get_latency;out->stream.set_volume = out_set_volume;out->stream.write = out_write;out->stream.get_render_position = out_get_render_position;out->stream.get_next_write_timestamp = out_get_next_write_timestamp;out->stream.set_callback = out_set_callback;out->stream.get_presentation_position = out_get_presentation_position;*stream_out = &out->stream;return 0;err_open:free(out);*stream_out = NULL;return ret;
}

-》AudioHardwareALSA::openOutputStream

-》

android_audio_legacy::AudioStreamOut *AudioALSAHardware::openOutputStream(uint32_t devices,int *format,uint32_t *channels,uint32_t *sampleRate,status_t *status)
{return mStreamManager->openOutputStream(devices, format, channels, sampleRate, status);
}

/*==============================================================================
* Implementations
============================================================================/

-》
android_audio_legacy::AudioStreamOut *AudioALSAStreamManager::openOutputStream(
uint32_t devices,
int *format,
uint32_t *channels,
uint32_t *sampleRate,
status_t *status)
{
ALOGD(“+%s()”, FUNCTION);
AudioAutoTimeoutLock streamVectorAutoTimeoutLock(mStreamVectorLock);
AudioAutoTimeoutLock _l(mLock);

if (format == NULL || channels == NULL || sampleRate == NULL || status == NULL)
{ALOGE("%s(), NULL pointer!! format = %p, channels = %p, sampleRate = %p, status = %p",__FUNCTION__, format, channels, sampleRate, status);if (status != NULL) { *status = INVALID_OPERATION; }return NULL;
}// stream out flags
const uint32_t flags = (uint32_t)(*status);// create stream out
AudioALSAStreamOut *pAudioALSAStreamOut = new AudioALSAStreamOut();
pAudioALSAStreamOut->set(devices, format, channels, sampleRate, status, flags);
if (*status != NO_ERROR)
{ALOGE("-%s(), set fail, return NULL", __FUNCTION__);delete pAudioALSAStreamOut;pAudioALSAStreamOut = NULL;return NULL;
}// save stream out object in vector
pAudioALSAStreamOut->setIdentity(mStreamOutIndex);
mStreamOutVector.add(mStreamOutIndex, pAudioALSAStreamOut); // 加入到streammanager 容器中。
mStreamOutIndex++;// setup Filter for ACF/HCF/AudEnh/VibSPK // TODO Check return status of pAudioALSAStreamOut->set
AudioMTKFilterManager *pAudioFilterManagerHandler = new AudioMTKFilterManager(*sampleRate, android_audio_legacy::AudioSystem::popCount(*channels), *format, pAudioALSAStreamOut->bufferSize());
mFilterManagerVector.add(mFilterManagerNumber, pAudioFilterManagerHandler);
mFilterManagerNumber++;ALOGD("-%s(), out = %p, status = 0x%x, mStreamOutVector.size() = %d",__FUNCTION__, pAudioALSAStreamOut, *status, mStreamOutVector.size());return pAudioALSAStreamOut;
}

-》audioAStreamManager::openOutputStream
-》audioALSAStreamOut::open
-》audioALSAStreamOut::open()
-》playbackHandler = mStreamManager->createPlaybackHandler(&mStreamAttributeSource);
-> // open codec driver
mHardwareResourceManager->startOutputDevice(mStreamAttributeSource->output_devices, mStreamAttributeTarget.sample_rate);