Android Audio

音频系统

初始化
在 system_init（运行在 Simulator 上）或者 main_Mediaserver中，AudioFlinger被创建，会生
成一个 AudioHardwareInterface实例（Android 定义的音频设备的一个抽象层） ，并且初始化
音频系统的模式和路由信息如下：
mHardwareStatus = AUDIO_HW_IDLE;
mAudioHardware = AudioHardwareInterface::create();
mHardwareStatus = AUDIO_HW_INIT;
if (mAudioHardware->initCheck() == NO_ERROR) {
// open 16-bit output stream for s/w mixer
mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
mOutput = mAudioHardware->openOutputStream(AudioSystem::PCM_16_BIT);
mHardwareStatus = AUDIO_HW_IDLE;
if (mOutput) {
mSampleRate = mOutput->sampleRate();
mChannelCount = mOutput->channelCount(); mFormat = mOutput->format();
mMixBufferSize = mOutput->bufferSize();
mFrameCount = mMixBufferSize / mChannelCount / sizeof(int16_t);
mMixBuffer = new int16_t[mFrameCount * mChannelCount];
memset(mMixBuffer, 0, mMixBufferSize);
mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);
// FIXME - this should come from settings
setMasterVolume(1.0f);
setRouting(AudioSystem::MODE_NORMAL, AudioSystem::ROUTE_SPEAKER,
AudioSystem::ROUTE_ALL);
setRouting(AudioSystem::MODE_RINGTONE,
AudioSystem::ROUTE_SPEAKER, AudioSystem::ROUTE_ALL);
setRouting(AudioSystem::MODE_IN_CALL, AudioSystem::ROUTE_EARPIECE,
AudioSystem::ROUTE_ALL);
setMode(AudioSystem::MODE_NORMAL);
mMasterMute = false;
} else {
LOGE("Failed to initialize output stream");
}
} else {
LOGE("Couldn't even initialize the stubbed audio hardware!");
}
在 SystemServer启动的时候，会生成一个 AudioService 的实例，
try {
Log.i(TAG, "Starting Audio Service");
ServiceManager.addService(Context.AUDIO_SERVICE, new
AudioService(context));
} catch (Throwable e) {
Log.e(TAG, "Failure starting Volume Service", e);
}
AudioService的构造函数会读取一些关于音频的配置信息，比如 Ringer和 vibrate 信息，
private void readPersistedSettings() {
final ContentResolver cr = mContentResolver;
mRingerMode = System.getInt(cr, System.MODE_RINGER,
AudioManager.RINGER_MODE_NORMAL);
mRingerModeAffectedStreams = System.getInt(mContentResolver,
System.MODE_RINGER_STREAMS_AFFECTED, 1 <<
AudioSystem.STREAM_RING);
mVibrateSetting = System.getInt(cr, System.VIBRATE_ON, 0);
mMuteAffectedStreams = System.getInt(cr,
System.MUTE_STREAMS_AFFECTED, ((1 << AudioSystem.STREAM_MUSIC)|(1 <<
AudioSystem.STREAM_RING)|(1 << AudioSystem.STREAM_SYSTEM)));
// Each stream will read its own persisted settings
// Broadcast the sticky intent
broadcastRingerMode();
// Broadcast vibrate settings
broadcastVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER);
broadcastVibrateSetting(AudioManager.VIBRATE_TYPE_NOTIFICATION);
}
同时也会从底层音频系统读取模式和路由信息：
private void readAudioSettings() {
synchronized (mSettingsLock) {
mMicMute = AudioSystem.isMicrophoneMuted();
mMode = AudioSystem.getMode();
for (int mode = 0; mode < AudioSystem.NUM_MODES; mode++) {
mRoutes[mode] = AudioSystem.getRouting(mode);
}
}
}
在 AudioSystem.cpp 第一次调用 get_audio_flinger 成功后，它会通过 binder 来监听运行在
media_server进程中的 AudioFlinger是否活着。
// establish binder interface to AudioFlinger service
const sp<IAudioFlinger>& AudioSystem::get_audio_flinger()
{
Mutex::Autolock _l(gLock);
if (gAudioFlinger.get() == 0) {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder;
do {
binder = sm->getService(String16("media.audio_flinger"));
if (binder != 0)
break;
LOGW("AudioFlinger not published, waiting...");
usleep(500000); // 0.5 s
} while(true);
if (gDeathNotifier == NULL) {
gDeathNotifier = new DeathNotifier();
} else {
if (gAudioErrorCallback) {
gAudioErrorCallback(NO_ERROR);
} }
binder->linkToDeath(gDeathNotifier);
gAudioFlinger = interface_cast<IAudioFlinger>(binder);
}
LOGE_IF(gAudioFlinger==0, "no AudioFlinger!?");
return gAudioFlinger;
}
到此，整个音频系统初始化完毕。
重新启动
如果 AudioFlinger运行的media_server进程异常死掉，AudioSystem会收到一个事件通知，
void AudioSystem::DeathNotifier::binderDied(const wp<IBinder>& who) {
Mutex::Autolock _l(AudioSystem::gLock);
AudioSystem::gAudioFlinger.clear();
if (gAudioErrorCallback) {
gAudioErrorCallback(DEAD_OBJECT);
}
LOGW("AudioFlinger server died!");
}
从而调用 android_media_AudioSystem.cpp 注册下来的回调函数，该函数又是通过 JNI 来调
用AudioService.java注册下来的回调函数， 在该函数中会发送MSG_MEDIA_SERVER_DIED
消息，AudioService 会监听这个消息，这样 AudioService 就能知道 AudioFlinger已不工作，
它就接着调用 getMode来尝试连接到重启后的 AudioFlinger。
case MSG_MEDIA_SERVER_DIED:
Log.e(TAG, "Media server died.");
// Force creation of new IAudioflinger interface
mMediaServerOk = false;
AudioSystem.getMode();
break;
当连接成功后，AudioFlinger会调用 android_media_AudioSystem.cpp 注册下来的回调函数，
该函数又是通过 JNI 来调用 AudioService.java 注册下来的回调函数，在该函数中会发送
MSG_MEDIA_SERVER_STARTED 消息。接着 AudioService 就去配置底层音频系统，包括
模式、路由、每一路流的音量大小和 Ringer状态。
case MSG_MEDIA_SERVER_STARTED:
// Restore audio routing and stream volumes
applyAudioSettings();
for (int streamType = AudioSystem.NUM_STREAMS - 1; streamType
>= 0; streamType--) {
int volume;
VolumeStreamState streamState = mStreamStates[streamType];
if (streamState.muteCount() == 0) {
volume = streamState.mVolumes[streamState.mIndex]; } else {
volume = streamState.mVolumes[0];
}
AudioSystem.setVolume(streamType, volume);
}
setRingerMode();
Note: AudioSystem 的 Native 实现在
device/libs/android_runtime/android_media_AudioSystem.cpp中。
模式
初始的时候音频系统是处于 MODE_NORMAL 模式的，下面是其模式状态变迁图：

问题：
当一个 Ringtone 放完了之后， 理论上系统是否要自动切换回 NORMAL 模式而不是必须
要主动调用 stopRing？我没找到相关 code。
路由信息
1. 当 HeadsetObserver 检测到有耳机插上来的时候，它会把音频系统的路由设置成均使用
该耳机； 当耳机被拔下来后， 它会把音频系统的路由设置成缺省配置 （即都通过扬声器） 。
private synchronized final void update(String newName, int newState) {
if (newName != mHeadsetName || newState != mHeadsetState) {
mHeadsetName = newName;
mHeadsetState = newState;
AudioManager audioManager = (AudioManager)
mContext.getSystemService(Context.AUDIO_SERVICE);
if (mHeadsetState == 1) {
audioManager.setRouting(AudioManager.MODE_NORMAL,
AudioManager.ROUTE_HEADSET,
AudioManager.ROUTE_ALL);
audioManager.setRouting(AudioManager.MODE_RINGTONE, AudioManager.ROUTE_HEADSET |
AudioManager.ROUTE_SPEAKER,
AudioManager.ROUTE_ALL);
audioManager.setRouting(AudioManager.MODE_IN_CALL,
AudioManager.ROUTE_HEADSET,
AudioManager.ROUTE_ALL);
} else {
audioManager.setRouting(AudioManager.MODE_NORMAL,
AudioManager.ROUTE_SPEAKER,
AudioManager.ROUTE_ALL);
audioManager.setRouting(AudioManager.MODE_RINGTONE,
AudioManager.ROUTE_SPEAKER,
AudioManager.ROUTE_ALL);
audioManager.setRouting(AudioManager.MODE_IN_CALL,
AudioManager.ROUTE_EARPIECE,
AudioManager.ROUTE_ALL);
}
sendIntent();
}
}
PhoneApp 会接收到一个 ACTION_HEADSET_PLUG 的 Intent，往自身发送一个消息，处理
如下：只是在没有蓝牙耳机或者未使用蓝牙耳机，而且该有线耳机是被拔掉的情况下，才把
路由信息设置成 MODE_IN_CALL 走 ROUTE_SPEAKER。
case EVENT_WIRED_HEADSET_PLUG:
// Since the presence of a wired headset or bluetooth affects the
// speakerphone, update the "speaker" state. We ONLY want to do
// this on the wired headset connect / disconnect events for now
// though, so we're only triggering on
EVENT_WIRED_HEADSET_PLUG.
if (!isHeadsetPlugged() &&
(mBtHandsfree == null || !mBtHandsfree.isAudioOn())) {
// is the state is "not connected", restore the speaker state.
PhoneUtils.restoreSpeakerMode(getApplicationContext());
}
NotificationMgr.getDefault().updateSpeakerNotification();
break;
问题：
假设耳机插上来之前是通过蓝牙耳机在接听电话（或者听音乐）的，耳机插上来的时候
系统就自动切换到使用耳机了，但是 PhoneApp这个时候并不知道，它还以为在继续使用蓝
牙耳机。但当耳机拔掉之后，怎么再切换回继续使用蓝牙耳机呢（系统默认是切换成
EARPIECE）？这个时候 PhoneApp 的状态应该是不对的。
2. 当在 Setting里面把蓝牙耳机配对和 RFCOMM 连接上之后，BluetoothHeadsetService会
负责去和蓝牙耳机建立 SCO 连接，当连接完成之后 BluetoothHandsfree 会调用
AudioManager的setBluetoothScoOn函数来通知音频系统去切换MODE_IN_CALL路由信息到使用 ROUTE_BLUETOOTH。
/**
* Sets audio routing to the Bluetooth headset on or off.
*
* @param on set <var>true</var> to route SCO (voice) audio to/from Bluetooth
* headset; <var>false</var> to route audio to/from phone earpiece
*/
public void setBluetoothScoOn(boolean on){
setRouting(MODE_IN_CALL, on ? ROUTE_BLUETOOTH : ROUTE_EARPIECE,
ROUTE_ALL);
}
当蓝牙设备被关闭或者链接断掉的时候，BluetoothHeadsetService 会收到一个
DISABLED_ACTION 的 Intent ，接着 BluetoothHandsfree 会调用 AudioManager 的
setBluetoothScoOn 函数来通知音频系统去切换 MODE_IN_CALL 路由信息到
ROUTE_EARPIECE。
问题：
setBluetoothScoOn 的实现在处理蓝牙设备被关闭的时候，是直接把路由信息改成到
ROUTE_EARPIECE，并没有恢复到使用蓝牙设备之前的信息状态。
Ringtone 是否需要在蓝牙耳机上播放呢？
音量控制
对外接口是 AudioManager
播放
音频系统对外的播放接口是 AudioTrack，每一路音频会对应一个 AudioTrack 的实例，它会
通过 iBinder来远程调用 AudioFlinger的 createTrack 函数。
// create the track
sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),
streamType, sampleRate, format, channelCount, bufferCount, flags);
if (track == 0) {
LOGE("AudioFlinger could not create track");
return NO_INIT;
}
sp<IMemory> cblk = track->getCblk();
if (cblk == 0) {
LOGE("Could not get control block");
return NO_INIT;
}
而 AudioFlinger 的 createTrack 又会在内部生成一个 Track 实例，再将其包装成 TrackHandle
返回给 AudioTrack。
track = new Track(this, client, streamType, sampleRate, format, channelCount, bufferCount, channelCount == 1 ? mMixBufferSize>>1 :
mMixBufferSize);
mTracks.add(track);
trackHandle = new TrackHandle(track);
return trackHandle;
所以 AudioTrack和 AudioFlinger 实际操作的都是 Track 实例， AudioTrack 通过它来执行控制
操作（start/stop）和写入操作（write） ，AudioFlinger 则负责管理多个 Track（包括调用
AudioMixer来混音） 。两者之间的关系可以用生产者/消费者来类比，AudioTrack 是生产者，
AudioFlinger则是消费者。
AudioTrack
AudioTrack的 start/stop操作可以理解成一个开关， 控制的是是否将与之对应的 Track实例纳
入 AudioFlinger的管理中去，下面仅以 start 操作为例。
void AudioTrack::start()
{
LOGV("start");
if (mAudioTrackThread != 0) {
mAudioTrackThread->mLock.lock();
}
if (android_atomic_or(1, &mActive) == 0) {
setpriority(PRIO_PROCESS, 0, THREAD_PRIORITY_AUDIO_CLIENT);
mActive = 1;
mAudioTrack->start();
if (mAudioTrackThread != 0) {
mAudioTrackThread->run("AudioTrackThread",
THREAD_PRIORITY_AUDIO_CLIENT);
}
}
if (mAudioTrackThread != 0) {
mAudioTrackThread->mLock.unlock();
}
}
status_t AudioFlinger::TrackHandle::start() {
return mTrack->start();
}
status_t AudioFlinger::Track::start()
{
LOGV("start(%d)", mName);
mAudioFlinger->addTrack(this);
return NO_ERROR; }
status_t AudioFlinger::addTrack(const sp<Track>& track)
{
Mutex::Autolock _l(mLock);
// here the track could be either new, or restarted
// in both cases "unstop" the track
if (track->isPaused()) {
track->mState = TrackBase::RESUMING;
LOGV("PAUSED => RESUMING (%d)", track->name());
} else {
track->mState = TrackBase::ACTIVE;
LOGV("? => ACTIVE (%d)", track->name());
}
LOGV("mWaitWorkCV.broadcast");
mWaitWorkCV.broadcast();
if (mActiveTracks.indexOf(track) < 0) {
// the track is newly added, make sure it fills up all its
// buffers before playing. This is to ensure the client will
// effectively get the latency it requested.
track->mFillingUpStatus = Track::FS_FILLING;
mActiveTracks.add(track);
return NO_ERROR;
}
return ALREADY_EXISTS;
}
AudioTrack的 write 则是往 audio_track_cblk_t 结构中写入数据。
ssize_t AudioTrack::write(const void* buffer, size_t userSize)
{
LOGV("write %d bytes, mActive=%d", userSize, mActive);
ssize_t written = 0;
do {
if (mPosition == 0) {
status_t err = obtainBuffer(&mAudioBuffer, true);
if (err < 0) {
// out of buffers, return #bytes written
if (err == status_t(NO_MORE_BUFFERS))
break;
return ssize_t(err);
}
}
size_t capacity = mAudioBuffer.size - mPosition;
size_t toWrite = userSize < capacity ? userSize : capacity;
memcpy(mAudioBuffer.i8 + mPosition, buffer, toWrite);
buffer = static_cast<const int8_t*>(buffer) + toWrite;
mPosition += toWrite;
userSize -= toWrite;
capacity -= toWrite;
written += toWrite;
if (capacity == 0) {
mPosition = 0;
releaseBuffer(&mAudioBuffer);
}
} while (userSize);
return written;
}
AudioFlinger
AudioFlinger 对 Track 的管理是实现在 threadLoop 中的。先检测进入 standby 的超时是否到
了， 超时的话 AudioFlinger会调用 AudioHardwareInterface的 standby， 这个是为省电考虑的。
nsecs_t standbyTime = systemTime();
do {
enabledTracks = 0;
{ // scope for the lock
Mutex::Autolock _l(mLock);
const SortedVector< wp<Track> >& activeTracks = mActiveTracks;
// put audio hardware into standby after short delay
if UNLIKELY(systemTime() > standbyTime) {
// wait until we have something to do...
LOGD("Audio hardware entering standby\n");
mHardwareStatus = AUDIO_HW_STANDBY;
if (!mStandby) {
mAudioHardware->standby();
mStandby = true;
}
mHardwareStatus = AUDIO_HW_IDLE;
// we're about to wait, flush the binder command buffer
IPCThreadState::self()->flushCommands();
mWaitWorkCV.wait(mLock);
LOGD("Audio hardware exiting standby\n");
standbyTime = systemTime() + kStandbyTimeInNsecs; continue;
}
如果未进 standby，接下来遍历所有当前 Active的 Track 实例。
// find out which tracks need to be processed
size_t count = activeTracks.size();
for (size_t i=0 ; i<count ; i++) {
sp<Track> t = activeTracks[i].promote();
if (t == 0) continue;
Track* const track = t.get();
audio_track_cblk_t* cblk = track->cblk();
uint32_t u = cblk->user;
uint32_t s = cblk->server;
// The first time a track is added we wait
// for all its buffers to be filled before processing it
audioMixer().setActiveTrack(track->name());
当有某个 Track 的数据需要处理时（数据存储在 audio_track_cblk_t 结构中，其 user 域表明
当前写入指针在 buffer中的位置， server域表明读取指针在 buffer中的位置， 所以只有当user
大于 server的时候说明有数据要处理） ，先计算该 Track 的 volume 信息，然后去配置针对该
路 Track 的Mixer信息。
if ((u > s) && (track->isReady(u, s) || track->isStopped()) &&
!track->isPaused())
{
// compute volume for this track
// setup mixer needed information here
AudioMixer& mixer(audioMixer());
mixer.setBufferProvider(track);
mixer.enable(AudioMixer::MIXING);
enabledTracks++;
} else {
最后进入真正的混音操作，再把混音过后的数据写到 AudioHardwareInterface 生成的
AudioOutputStream中，由此整个音频输出完成。
if (LIKELY(enabledTracks)) {
// mix buffers...
audioMixer().process(curBuf);
// output audio to hardware
mLastWriteTime = systemTime();
mInWrite = true;
mOutput->write(curBuf, mixBufferSize);
mNumWrites++;
mInWrite = false; mStandby = false;
nsecs_t temp = systemTime();
standbyTime = temp + kStandbyTimeInNsecs;
nsecs_t delta = temp - mLastWriteTime;
if (delta > maxPeriod) {
LOGW("write blocked for %llu msecs", ns2ms(delta));
mNumDelayedWrites++;
}
sleepTime = kBufferRecoveryInUsecs;
} else {
当所有 Active 的 Track 都没有数据需要处理的时候，AudioFlinger会 usleep 一段时间从而进
入 standby。
// There was nothing to mix this round, which means all
// active tracks were late. Sleep a little bit to give
// them another chance. If we're too late, the audio
// hardware will zero-fill for us.
LOGV("no buffers - usleep(%lu)", sleepTime);
usleep(sleepTime);
if (sleepTime < kMaxBufferRecoveryInUsecs) {
sleepTime += kBufferRecoveryInUsecs;
}
录制
音频系统对外的录制接口是 AudioRecord，它会通过 iBinder 来远程调用 AudioFlinger 的
openRecord函数。
// open record channel
sp<IAudioRecord> record = audioFlinger->openRecord(getpid(), streamType,
sampleRate, format, channelCount, bufferCount, flags);
if (record == 0) {
return NO_INIT;
}
sp<IMemory> cblk = record->getCblk();
if (cblk == 0) {
return NO_INIT;
}
if (cbf != 0) {
mClientRecordThread = new ClientRecordThread(*this);
if (mClientRecordThread == 0) {
return NO_INIT;
}
}
而 AudioFlinger 的 openRecord 又会在内部先生成一个 AudioRecordThread 并且拿到
AudioStreamIn， // Create audio thread - take mutex to prevent race condition
{
Mutex::Autolock _l(mLock);
if (mAudioRecordThread != 0) {
LOGE("Record channel already open");
goto Exit;
}
thread = new AudioRecordThread(this);
mAudioRecordThread = thread;
}
// It's safe to release the mutex here since the client doesn't get a
// handle until we return from this call
// open driver, initialize h/w
input = mAudioHardware->openInputStream(
AudioSystem::PCM_16_BIT, channelCount, sampleRate);
再生成一个 RecordTrack实例，将其包装成 RecordTrackHandle返回给 AudioRecord。
// create new record track and pass to record thread
recordTrack = new RecordTrack(this, client, streamType, sampleRate,
format, channelCount, bufferCount, input->bufferSize());
// spin up record thread
thread->open(recordTrack, input);
thread->run("AudioRecordThread", PRIORITY_URGENT_AUDIO);
// return to handle to client
recordHandle = new RecordHandle(recordTrack);
所以 AudioRecord 和 AudioFlinger 实际操作的都是 RecordTrack 实例，AudioRecord 通过它
来执行控制操作（start/stop）和读取操作（read） ，AudioFlinger 则负责从音频设备读取数据
并放入 audio_track_cblk_t 结构中。两者之间的关系也可以用生产者/消费者来类比，
AudioRecord是消费者，AudioFlinger则是生产者。
AudioRecord
AudioRecord 的 start/stop 操作可以理解成一个开关，控制的是 AudioRecordThread 的运行与
否，下面仅以 start 操作为例。
status_t AudioRecord::start()
{
status_t ret = NO_ERROR;
// If using record thread, protect start sequence to make sure that
// no stop command is processed before the thread is started
if (mClientRecordThread != 0) {
mRecordThreadLock.lock();
}
if (android_atomic_or(1, &mActive) == 0) {
setpriority(PRIO_PROCESS, 0, THREAD_PRIORITY_AUDIO_CLIENT);
ret = mAudioRecord->start();
if (ret == NO_ERROR) {
if (mClientRecordThread != 0) {
mClientRecordThread->run("ClientRecordThread",
THREAD_PRIORITY_AUDIO_CLIENT);
}
}
}
if (mClientRecordThread != 0) {
mRecordThreadLock.unlock();
}
return ret;
}
status_t AudioFlinger::RecordHandle::start() {
LOGV("RecordHandle::start()");
return mRecordTrack->start();
}
status_t AudioFlinger::RecordTrack::start()
{
return mAudioFlinger->startRecord();
}
status_t AudioFlinger::startRecord() {
sp<AudioRecordThread> t = audioRecordThread();
if (t == 0) return NO_INIT;
return t->start();
}
AudioFlinger
从音频设备获取声音是实现在 AudioRecordThread::threadLoop中的。
// promote strong ref so track isn't deleted while we access it
sp<RecordTrack> t = mRecordTrack.promote();
// if we lose the weak reference, client is gone.
if (t == 0) {
LOGV("AudioRecordThread: client deleted track");
break; }
if (LIKELY(t->getNextBuffer(&mBuffer) == NO_ERROR)) {
if (mInput->read(mBuffer.raw, t->mBufferSize) < 0) {
LOGE("Error reading audio input");
sleep(1);
}
t->releaseBuffer(&mBuffer);
}
// client isn't retrieving buffers fast enough
else {
if (!t->setOverflow())
LOGW("AudioRecordThread: buffer overflow");
}