启动AudioFlinger学习笔记----深入理解Android

main@main_mediaServer.cpp

int main(int argc, char** argv)
{
    ......
    AudioFlinger::instantiate();
    ......
    AudioPolicyService::instantiate();
    ......
}

AudioFlinger

void AudioFlinger::instantiate() {
    defaultServiceManager()->addService(
            String16("media.audio_flinger"), new AudioFlinger());
}

AudioFlinger::AudioFlinger()
    : BnAudioFlinger(),
        mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1), mFmOn(false)
{
    mHardwareStatus = AUDIO_HW_IDLE;
    mLPAOutput = NULL;
    mLPAHandle = -1;
    mLPAStreamIsActive = false;
    mLPASessionId = -2; // -2 is invalid session ID
    mIsEffectConfigChanged = false;
    mLPAEffectChain = NULL;

    mAudioHardware = AudioHardwareInterface::create();

    mHardwareStatus = AUDIO_HW_INIT;
    if (mAudioHardware->initCheck() == NO_ERROR) {
        // open 16-bit output stream for s/w mixer
        mMode = AudioSystem::MODE_NORMAL;
        setMode(mMode);

        setMasterVolume(1.0f);
        setMasterMute(false);
    } else {
        LOGE("Couldn't even initialize the stubbed audio hardware!");
    }
}

AudioHardwareInterface::create()

AudioHardwareInterface* AudioHardwareInterface::create()
{
    /*
     * FIXME: This code needs to instantiate the correct audio device
     * interface. For now - we use compile-time switches.
     */
    AudioHardwareInterface* hw = 0;
    char value[PROPERTY_VALUE_MAX];

    // if running in emulation - use the emulator driver
    property_get("ro.kernel.qemu", value, 0);
    if(strcmp(value, "1") == 0) {
        LOGD("Running in emulation - using generic audio driver");
        hw = new AudioHardwareGeneric();
    }
    else {
        LOGV("Creating Vendor Specific AudioHardware");
        hw = createAudioHardware();
    }

    if (hw->initCheck() != NO_ERROR) {
        LOGW("Using stubbed audio hardware. No sound will be produced.");
        delete hw;
        hw = new AudioHardwareStub();
    }

#ifdef WITH_A2DP
    hw = new A2dpAudioInterface(hw);
#endif

    return hw;
}

createAudioHardware()@AudioHardware.cpp

extern "C" AudioHardwareInterface* createAudioHardware(void) {
    return new AudioHardware();
}

AudioHardware

AudioHardware::AudioHardware() :
    mInit(false), mMicMute(true), mBluetoothNrec(true), mBluetoothId(0),
    mOutput(0),
    mRealCall(false), /*MIN@Tecace - 20110722*/
    mFactoryTest(false),
    mTtyMode(TTY_OFF), mDualMicEnabled(false), mFmFd(-1),
    mCurRX(INVALID_DEVICE), mCurTX(INVALID_DEVICE)
{

        head = (Routing_table* ) malloc(sizeof(Routing_table));
        head->next = NULL;

        LOGE("msm_mixer_open: Opening the device");
        control = msm_mixer_open("/dev/snd/controlC0", 0);
        if(control< 0)
                LOGE("ERROR opening the device");

        mixer_cnt = msm_mixer_count();
        LOGE("msm_mixer_count:mixer_cnt =%d",mixer_cnt);

        dev_cnt = msm_get_device_count();
        LOGE("got device_count %d",dev_cnt);
        if (dev_cnt <= 0) {
                LOGE("NO devices registered\n");
                return;
        }
        name = msm_get_device_list();
        device_list = (Device_table* )malloc(sizeof(Device_table)*120);
        ......
        else if(strcmp((char* )name[i], "headset_fmradio_tx") == 0)
                    index = DEVICE_HEADSET_FMRADIO_TX;
            else if(strcmp((char* )name[i], "speaker_fmradio_rx") == 0)
                    index = DEVICE_SPEAKER_FMRADIO_RX;
            else if(strcmp((char* )name[i], "speaker_headset_fmradio_rx") == 0)
                    index = DEVICE_SPEAKER_HEADSET_FMRADIO_RX;
            else if(strcmp((char* )name[i], "speaker_voice_dialer_tx") == 0)
                    index = DEVICE_SPEAKER_VOICE_DIALER_TX;
            else if(strcmp((char* )name[i], "headset_voice_dialer_tx") == 0)
                    index = DEVICE_HEADSET_VOICE_DIALER_TX;
            else if(strcmp((char* )name[i], "bt_sco_voice_dialer_tx") == 0)
                    index = DEVICE_BT_SCO_VOICE_DIALER_TX;
        ........
    }
    mInit = true;    //mInit为static类型参数
}

AudioPolicyService init

void AudioPolicyService::instantiate() {
    defaultServiceManager()->addService(
            String16("media.audio_policy"), new AudioPolicyService());
}

AudioPolicyService::AudioPolicyService()
    : BnAudioPolicyService() , mpPolicyManager(NULL)
{
    char value[PROPERTY_VALUE_MAX];

    // start tone playback thread
    mTonePlaybackThread = new AudioCommandThread(String8(""));
    // start audio commands thread
    mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread"));

    ......
        mpPolicyManager = createAudioPolicyManager(this);
    ......
    mpPolicyManager->setSystemProperty("ro.camera.sound.forced", value);
}

createAudioPolicyManager(this)

extern "C" AudioPolicyInterface*  createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
{
    return new AudioPolicyManager(clientInterface);
}

AudioPolicyManager

AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
    : AudioPolicyManagerBase(clientInterface)
{
    ......
}

AudioPolicyManagerBase(clientInterface)

AudioPolicyManagerBase::AudioPolicyManagerBase(AudioPolicyClientInterface *clientInterface)
    :
#ifdef AUDIO_POLICY_TEST
    Thread(false),
#endif //AUDIO_POLICY_TEST
    mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),
    mMusicStopTime(0), mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
    mTotalEffectsCpuLoad(0), mTotalEffectsMemory(0),
    mA2dpSuspended(false)
{
    mpClientInterface = clientInterface;

    for (int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {
        mForceUse[i] = AudioSystem::FORCE_NONE;
    }

    // devices available by default are speaker, ear piece and microphone
    mAvailableOutputDevices = AudioSystem::DEVICE_OUT_EARPIECE | AudioSystem::DEVICE_OUT_SPEAKER;
    mAvailableInputDevices = AudioSystem::DEVICE_IN_BUILTIN_MIC;

#ifdef WITH_A2DP
    mA2dpOutput = 0;
    mDuplicatedOutput = 0;
    mA2dpDeviceAddress = String8("");
#endif
    mScoDeviceAddress = String8("");

    // open hardware output
    AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();
    outputDesc->mDevice = (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;
    mHardwareOutput = mpClientInterface->openOutput(&outputDesc->mDevice,
                                    &outputDesc->mSamplingRate,
                                    &outputDesc->mFormat,
                                    &outputDesc->mChannels,
                                    &outputDesc->mLatency,
                                    outputDesc->mFlags);

    ......
        addOutput(mHardwareOutput, outputDesc);    //mHardwareOutput是输出线程的索引值，outputDesc是输出设备描述符，两者所谓K-V组对
        setOutputDevice(mHardwareOutput, (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER, true);
    ......

    updateDeviceForStrategy();
}


mpClientInterface->openOutput()---->AudioPolicyService::openOutput()---->AudioFlinger::openOutput()
int AudioFlinger::openOutput(uint32_t *pDevices,
                                uint32_t *pSamplingRate,
                                uint32_t *pFormat,
                                uint32_t *pChannels,
                                uint32_t *pLatencyMs,
                                uint32_t flags)
{
    status_t status;
    PlaybackThread *thread = NULL;
    mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;

    Mutex::Autolock _l(mLock);

    AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices,
                                                             (int *)&format,
                                                             &channels,
                                                             &samplingRate,
                                                             &status);

    mHardwareStatus = AUDIO_HW_IDLE;
    if (output != 0) {
        int id = nextUniqueId();

            thread = new MixerThread(this, output, id, *pDevices);
            LOGV("openOutput() created mixer output: ID %d thread %p", id, thread);

        mPlaybackThreads.add(id, thread);

        // if the device is a A2DP, then this is an A2DP Output
        if ( true == AudioSystem::isA2dpDevice((AudioSystem::audio_devices) *pDevices) )
        {
            mA2DPHandle = id;
            LOGV("A2DP device activated. The handle is set to %d", mA2DPHandle);
        }
        // notify client processes of the new output creation
        thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);
        return id;    //返回创建的thread的索引值，即[email protected]
    }

    return 0;
}

AudioHardward->openOutputStream()
AudioStreamOut* AudioHardware::openOutputStream(
        uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
{
    LOGV("openOutputStream()");
    { // scope for the lock
        Mutex::Autolock lock(mLock);

    ......
        // create new output stream
        AudioStreamOutMSM72xx* out = new AudioStreamOutMSM72xx();
        status_t lStatus = out->set(this, devices, format, channels, sampleRate);
        if (status) {
            *status = lStatus;
        }
        if (lStatus == NO_ERROR) {
            mOutput = out;
        } else {
            delete out;
        }
    }
    return mOutput;
}
AudioStreamOutMSM72xx()
AudioHardware::AudioStreamOutMSM72xx::AudioStreamOutMSM72xx() :
    mHardware(0), mFd(-1), mStartCount(0), mRetryCount(0), mStandby(true), mDevices(0)
{}

status_t AudioHardware::AudioStreamOutMSM72xx::set(
        AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate)
{
    ......

    LOGV("set mDevices %d", devices);
    mHardware = hw;
    ......
    mDevices = devices;

    return NO_ERROR;
}
nextUniqueId
int AudioFlinger::nextUniqueId()
{
    return android_atomic_inc(&mNextUniqueId);
}
MixerThread

AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)
    :   PlaybackThread(audioFlinger, output, id, device),
        mAudioMixer(0)
{
    mType = PlaybackThread::MIXER;
    mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);

    // FIXME - Current mixer implementation only supports stereo output
    if (mChannelCount == 1) {
        LOGE("Invalid audio hardware channel count");
    }
}
PlaybackThread
AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)
    :   ThreadBase(audioFlinger, id),
        mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output),
        mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
        mDevice(device)
{
    readOutputParameters();

    mMasterVolume = mAudioFlinger->masterVolume();
    mMasterMute = mAudioFlinger->masterMute();

    for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) {
        mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream);
        mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream);
    }
}
ThreadBase
AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, int id)
    :   Thread(false),
        mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mChannelCount(0),
        mFrameSize(1), mFormat(0), mStandby(false), mId(id), mExiting(false)
{
}
AudioMixer

AudioMixer::AudioMixer(size_t frameCount, uint32_t sampleRate)
    :   mActiveTrack(0), mTrackNames(0), mSampleRate(sampleRate)
{
    mState.enabledTracks= 0;
    mState.needsChanged = 0;
    mState.frameCount   = frameCount;
    mState.outputTemp   = 0;
    mState.resampleTemp = 0;
    mState.hook         = process__nop;
    track_t* t = mState.tracks;
    for (int i=0 ; i<32 ; i++) {
        t->needs = 0;
        t->volume[0] = UNITY_GAIN;
        t->volume[1] = UNITY_GAIN;
        t->volumeInc[0] = 0;
        t->volumeInc[1] = 0;
        t->auxLevel = 0;
        t->auxInc = 0;
        t->channelCount = 2;
        t->enabled = 0;
        t->format = 16;
        t->buffer.raw = 0;
        t->bufferProvider = 0;
        t->hook = 0;
        t->resampler = 0;
        t->sampleRate = mSampleRate;
        t->in = 0;
        t->mainBuffer = NULL;
        t->auxBuffer = NULL;
        t++;
    }
}

struct [email protected]
    struct state_t {
        uint32_t        enabledTracks;
        uint32_t        needsChanged;
        size_t          frameCount;
        mix_t           hook;
        int32_t         *outputTemp;
        int32_t         *resampleTemp;
        int32_t         reserved[2];
        track_t         tracks[32]; __attribute__((aligned(32)));
    };
state_t         mState __attribute__((aligned(32)));


读这些代码，总是有种被踢皮球的感觉，或者说类似西班牙Tiki-Taka的感觉。

系统首先初始化了Audio系统的核心模块AudioFlinger，然后初始化了AudioPolicyService以及AudioPolicyManagerBase。

AudioFlinger的构造函数初始化了BnAudioFlinger，并创建了HAL层对象mAudioHardward。

AudioPolicyServie通过openOutput函数(最终调用AudioFlinger里的openOutput函数)创建了MixerThread进行系统混音处理。

AudioPolicyManager负责HAL层device的选取，设备strage，output，descriptor等的记录(map组对)