2、audio_hw

3、tinyalsa

二、Audio Hardware HAL加载

1、AudioFlinger

//加载audio hardware hal
static int load_audio_interface(const char *if_name, const hw_module_t **mod,
                                audio_hw_device_t **dev)
{
    int rc;
    
    //根据classid和if_name找到指定的动态库并加载，这里加载的是音频动态库，如libaudio.primary.tuna.so
    rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, mod);
    if (rc)
        goto out;

    //加载好的动态库模块必有个open方法，调用open方法打开音频设备模块
    rc = audio_hw_device_open(*mod, dev);
    LOGE_IF(rc, "couldn't open audio hw device in %s.%s (%s)",
            AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
    if (rc)
        goto out;

    return 0;

out:
    *mod = NULL;
    *dev = NULL;
    return rc;
}

//音频设备接口，hw_get_module_by_class需要根据这些字符串找到相关的音频模块库
static const char *audio_interfaces[] = {
    "primary", //主音频设备，一般为本机codec
    "a2dp",    //a2dp设备，蓝牙高保真音频
    "usb",     //usb-audio设备，这个东东我2.3就考虑要实现了，现在终于支持了
};
#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0])))

// ----------------------------------------------------------------------------

AudioFlinger::AudioFlinger()
    : BnAudioFlinger(),
        mPrimaryHardwareDev(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1),
        mBtNrecIsOff(false)
{
}

void AudioFlinger::onFirstRef()
{
    int rc = 0;

    Mutex::Autolock _l(mLock);

    /* TODO: move all this work into an Init() function */
    mHardwareStatus = AUDIO_HW_IDLE;

    //打开audio_interfaces数组定义的所有音频设备
    for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) {
        const hw_module_t *mod;
        audio_hw_device_t *dev;

        rc = load_audio_interface(audio_interfaces[i], &mod, &dev);
        if (rc)
            continue;

        LOGI("Loaded %s audio interface from %s (%s)", audio_interfaces[i],
             mod->name, mod->id);
        mAudioHwDevs.push(dev); //mAudioHwDevs是一个Vector，存储已打开的audio hw devices

        if (!mPrimaryHardwareDev) {
            mPrimaryHardwareDev = dev;
            LOGI("Using '%s' (%s.%s) as the primary audio interface",
                 mod->name, mod->id, audio_interfaces[i]);
        }
    }

    mHardwareStatus = AUDIO_HW_INIT;

    if (!mPrimaryHardwareDev || mAudioHwDevs.size() == 0) {
        LOGE("Primary audio interface not found");
        return;
    }

    //对audio hw devices进行一些初始化，如mode、master volume的设置
    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
        audio_hw_device_t *dev = mAudioHwDevs[i];

        mHardwareStatus = AUDIO_HW_INIT;
        rc = dev->init_check(dev);
        if (rc == 0) {
            AutoMutex lock(mHardwareLock);

            mMode = AUDIO_MODE_NORMAL;
            mHardwareStatus = AUDIO_HW_SET_MODE;
            dev->set_mode(dev, mMode);
            mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
            dev->set_master_volume(dev, 1.0f);
            mHardwareStatus = AUDIO_HW_IDLE;
        }
    }
}

以上对AudioFlinger进行的分析，主要是通过hw_get_module_by_class()找到模块接口名字if_name相匹配的模块库，加载，然后audio_hw_device_open()调用模块的open方法，完成音频设备模块的初始化。

留意AudioFlinger的构造函数只有简单的私有变量的初始化操作了，把音频设备初始化放到onFirstRef()，Android终于改进了这一点，好的设计根本不应该把可能会失败的操作放到构造函数中。onFirstRef是RefBase类的一个虚函数，在构造sp的时候就会被调用。因此，在构造sp<AudioFlinger>的时候就会触发onFirstRef方法，从而完成音频设备模块初始化。

我们接下来看看hw_get_module_by_class，实现在hardware/libhardware/ hardware.c中，它作用加载指定名字的模块库（.so文件），这个应该是用于加载所有硬件设备相关的库文件，并不只是音频设备。

int hw_get_module_by_class(const char *class_id, const char *inst,
                           const struct hw_module_t **module)
{
    int status;
    int i;
    const struct hw_module_t *hmi = NULL;
    char prop[PATH_MAX];
    char path[PATH_MAX];
    char name[PATH_MAX];

    if (inst)
        snprintf(name, PATH_MAX, "%s.%s", class_id, inst);
    else
        strlcpy(name, class_id, PATH_MAX);
        
    //这里我们以音频库为例，AudioFlinger调用到这个函数时，
    //class_id=AUDIO_HARDWARE_MODULE_ID="audio"，inst="primary"(或"a2dp"或"usb")
    //那么此时name="audio.primary"

    /*
     * Here we rely on the fact that calling dlopen multiple times on
     * the same .so will simply increment a refcount (and not load
     * a new copy of the library).
     * We also assume that dlopen() is thread-safe.
     */

    /* Loop through the configuration variants looking for a module */
    for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {
        if (i < HAL_VARIANT_KEYS_COUNT) {
        	  //通过property_get找到厂家标记如"ro.product.board=tuna"，这时prop="tuna"
            if (property_get(variant_keys[i], prop, NULL) == 0) {
                continue;
            }
            snprintf(path, sizeof(path), "%s/%s.%s.so",
                     HAL_LIBRARY_PATH2, name, prop); //#define HAL_LIBRARY_PATH2 "/vendor/lib/hw"
            if (access(path, R_OK) == 0) break;

            snprintf(path, sizeof(path), "%s/%s.%s.so",
                     HAL_LIBRARY_PATH1, name, prop); //#define HAL_LIBRARY_PATH1 "/system/lib/hw"
            if (access(path, R_OK) == 0) break;
        } else {
            snprintf(path, sizeof(path), "%s/%s.default.so", //如没有指定的库文件，则加载default.so，即stub-device
                     HAL_LIBRARY_PATH1, name);
            if (access(path, R_OK) == 0) break;
        }
    }
    //到这里，完成一个模块库的完整路径名称，如path="/system/lib/hw/audio.primary.tuna.so"
    //如何生成audio.primary.tuna.so？请看相关的Android.mk文件，其中有定义LOCAL_MODULE := audio.primary.tuna

    status = -ENOENT;
    if (i < HAL_VARIANT_KEYS_COUNT+1) {
        /* load the module, if this fails, we're doomed, and we should not try
         * to load a different variant. */
        status = load(class_id, path, module); //加载模块库
    }

    return status;
}

load()函数不详细分析了，它通过dlopen加载库文件，然后dlsym找到hal_module_info的首地址。我们先看看hal_module_info的定义：

/**
 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
 * and the fields of this data structure must begin with hw_module_t
 * followed by module specific information.
 */
typedef struct hw_module_t {
    /** tag must be initialized to HARDWARE_MODULE_TAG */
    uint32_t tag;

    /** major version number for the module */
    uint16_t version_major;

    /** minor version number of the module */
    uint16_t version_minor;

    /** Identifier of module */
    const char *id;

    /** Name of this module */
    const char *name;

    /** Author/owner/implementor of the module */
    const char *author;

    /** Modules methods */
    struct hw_module_methods_t* methods;

    /** module's dso */
    void* dso;

    /** padding to 128 bytes, reserved for future use */
    uint32_t reserved[32-7];

} hw_module_t;

typedef struct hw_module_methods_t {
    /** Open a specific device */
    int (*open)(const struct hw_module_t* module, const char* id,
            struct hw_device_t** device);

} hw_module_methods_t;

这个结构体很重要，注释很详细。dlsym拿到这个结构体的首地址后，就可以调用Modules methods进行设备模块的初始化了。设备模块中，都应该按照这个格式初始化好这个结构体，否则dlsym找不到它，也就无法调用Modules methods进行初始化了。

例如，在audio_hw.c中，它是这样定义的：

static struct hw_module_methods_t hal_module_methods = {
    .open = adev_open,
};

struct audio_module HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,
        .version_major = 1,
        .version_minor = 0,
        .id = AUDIO_HARDWARE_MODULE_ID,
        .name = "Tuna audio HW HAL",
        .author = "The Android Open Source Project",
        .methods = &hal_module_methods,
    },
};

四、a2dp Audio HAL的实现

4.0的a2dp audio hal放到bluez里实现了，我找了好一会才找到：
external/Bluetooth/bluez/audio/android_audio_hw.c
大致与上面提到的audio_hw.c类似，因为都是基于audio.h定义的接口来实现的。
如果需要编译这个库，须在BoardConfig.mk里定义：
BOARD_HAVE_BLUETOOTH := true

开始还提到现在支持3种audio设备了，分别是primary、a2dp和usb。目前剩下usb audio hal我没有找到，不知是否需要自己去实现？其实alsa-driver都支持大部分的usb-audio设备了，因此上层也可调用tinyalsa的接口，就像samsung tuna的audio_hw.c那样。

五、音质改进？？？

可使用audio echo cancel和更好的resampler（SRC）？？？

--to be continued…