Linphone录音器的初始化流程分析

初始化入口：

linphone_core_init() ——linphonecore.c 1793

static void linphone_core_init(LinphoneCore * lc, const LinphoneCoreVTable *vtable, LpConfig *config, void * userdata){   const char *remote_provisioning_uri = NULL;   linphone_task_list_init(&lc->hooks);   _linphone_core_add_listener(lc, internal_vtable, TRUE, TRUE);   memcpy(local_vtable,vtable,sizeof(LinphoneCoreVTable));   _linphone_core_add_listener(lc, local_vtable, TRUE, FALSE);   lc->factory = ms_factory_new_with_voip();   linphone_core_register_default_codecs(lc);   linphone_core_register_offer_answer_providers(lc);   /* Get the mediastreamer2 event queue */   /* This allows to run event's callback in linphone_core_iterate() */   lc->msevq=ms_factory_create_event_queue(lc->factory);   lc->sal=sal_init(lc->factory);}

媒体库初始化在ms_factory_new_with_voip() —— msvoip.c 354

MSFactory *ms_factory_new_with_voip(void){    ms_message("ms_factory_new_with_voip");   MSFactory *f = ms_factory_new();   ms_factory_init_voip(f);   ms_factory_init_plugins(f);   return f;}

第一步、ms_factory_new()新建一个MSFactory对象
第二步、ms_factory_init_voip(),初始化voip；
第三步、ms_factory_init_plugins();初始化插件；

先分析第一步，ms_factory_new()只是实例化一个MSFactory结构体 位于msfactory.c line223

---

MSFactory *ms_factory_new(void){   MSFactory *obj=ms_new0(MSFactory,1);   ms_factory_init(obj);   return obj;}

ms_factory_init(); ——msfactory.c 144

void ms_factory_init(MSFactory *obj){    int i;    long num_cpu=1;    char *debug_log_enabled = NULL;    char *tags;    ...    ms_message("Mediastreamer2 factory " MEDIASTREAMER_VERSION " (git: " GIT_VERSION ") initialized.");    /* register builtin MSFilter's */     for (i=0;ms_base_filter_descs[i]!=NULL;i++){             ms_factory_register_filter(obj,ms_base_filter_descs[i]);    }    ms_factory_set_cpu_count(obj,num_cpu);    ms_factory_set_mtu(obj,MS_MTU_DEFAULT);    #ifdef ANDROID        ms_factory_add_platform_tag(obj, "android");    #endif    #ifdef TARGET_OS_IPHONE         ms_factory_add_platform_tag(obj, "ios");    #endif    ...    tags = ms_factory_get_platform_tags_as_string(obj);    ms_message("ms_factory_init() done: platform_tags=%s", tags);    ms_free(tags);}

主要是设置MSFactory*的一些属性，重点在中间的for循环。
其中的ms_base_filter_descs[]定义在basedesc.h中，

extern MSFilterDesc ms_tee_desc;extern MSFilterDesc ms_join_desc;extern MSFilterDesc ms_void_source_desc;extern MSFilterDesc ms_void_sink_desc;MSFilterDesc * ms_base_filter_descs[]={&ms_tee_desc,&ms_join_desc,&ms_void_source_desc,&ms_void_sink_desc,NULL};

而ms_factory_register_filter()在msfactory.c line 230

void ms_factory_register_filter(MSFactory* factory, MSFilterDesc* desc ) {    if (desc->id==MS_FILTER_NOT_SET_ID){             ms_fatal("MSFilterId for %s not set !",desc->name);     }    desc->flags|=MS_FILTER_IS_ENABLED; /*by default a registered filter is enabled*/    /*lastly registered encoder/decoders may replace older ones*/    factory->desc_list=bctbx_list_prepend(factory->desc_list,desc);}

将整个数组中定义的desc设置到factory->desc_list；

再看第二步ms_factory_init_voip（MSFactory *） 在msvoip.c line260

void ms_factory_init_voip(MSFactory *obj){    MSSndCardManager *cm;    int i;    if (obj->voip_initd) return;    ms_srtp_init();    obj->devices_info = ms_devices_info_new();        ......    #if defined(ANDROID) && defined(VIDEO_ENABLED)        if (AMediaImage_isAvailable()) {                ms_factory_register_filter(obj, &ms_mediacodec_h264_dec_desc);                ms_factory_register_filter(obj, &ms_mediacodec_h264_enc_desc);         }    #endif    /* register builtin VoIP MSFilter's */    for (i=0;ms_voip_filter_descs[i]!=NULL;i++){             ms_factory_register_filter(obj,ms_voip_filter_descs[i]);    }    cm=ms_snd_card_manager_new();    ms_message("Registering all soundcard handlers");    cm->factory=obj;    obj->sndcardmanager = cm;    for (i=0;ms_snd_card_descs[i]!=NULL;i++){             ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);    }    ...    #if defined(ANDROID) && defined (VIDEO_ENABLED)     {            MSDevicesInfo *devices = ms_factory_get_devices_info(obj);            SoundDeviceDescription *description = ms_devices_info_get_sound_device_description(devices);            if (description && description->flags & DEVICE_HAS_CRAPPY_OPENGL) {                if (!libmsandroiddisplay_init(obj)) {                     libmsandroiddisplaybad_init(obj);                }            } else {                libmsandroidopengldisplay_init(obj);                    }    }    #endif     obj->voip_initd=TRUE;    obj->voip_uninit_func = ms_factory_uninit_voip;     ms_message("ms_factory_init_voip() done");}

初始化有个重要的操作，构建一个MSSndCardManager对象，然后将系统允许的集中声卡注册进去；
其中ms_snd_card_manager_new() ，在mssndcard.c line27

MSSndCardManager * ms_snd_card_manager_new(void){        MSSndCardManager *obj=(MSSndCardManager *)ms_new0(MSSndCardManager,1);        obj->factory = NULL;        obj->cards=NULL;        obj->descs=NULL;        return obj;}

只是初始化一个MSSndCardManager结构体，并与外部传入的MSFactory互相关联属性；
ms_snd_card_descs[]是预先定义好的

static MSSndCardDesc * ms_snd_card_descs[]={    #ifdef MS2_FILTERS    ...    #ifdef __ALSA_ENABLED__        &alsa_card_desc,    #endif    ...    #ifdef ANDROID        &android_native_snd_card_desc,        &android_native_snd_opensles_card_desc,        &msandroid_sound_card_desc,    #endif    #endif /* MS2_FILTERS */    NULL};

对于Android 平台 一共定义了3中声卡模型，
其中的android_native_snd_card_desc定义在 androidsound.cpp中

MSSndCardDesc android_native_snd_card_desc={        "libmedia",                         //char* drive_type         android_snd_card_detect,       //detect        android_native_snd_card_init,   //init        NULL,                           //set_level        NULL,                           //get_level        NULL,                           //set_capture         NULL,                          //set_control        NULL,                           //get_control        android_snd_card_create_reader,//create_reader          android_snd_card_create_writer,//create_writer        android_native_snd_card_uninit  //duplicate};

android_native_snd_opensles_card_desc 定义在androidsound_opensles.cpp中

MSSndCardDesc android_native_snd_opensles_card_desc = {    "openSLES",    android_snd_card_detect,    android_native_snd_card_init,    NULL,       NULL,     NULL,    NULL,     NULL,    android_snd_card_create_reader,    android_snd_card_create_writer,    android_native_snd_card_uninit};

msandroid_sound_card_desc 定义在 androidsound_depr.cpp中

MSSndCardDesc msandroid_sound_card_desc = {/*.driver_type=*/"ANDROID SND (deprecated)",/*.detect=*/ msandroid_sound_detect,/*.init=*/msandroid_sound_init,/*.set_level=*/msandroid_sound_set_level,/*.get_level=*/msandroid_sound_get_level,/*.set_capture=*/msandroid_sound_set_source,    /*.set_control=*/NULL,  /*.get_control=*/NULL,/*.create_reader=*/msandroid_sound_read_new,/*.create_writer=*/msandroid_sound_write_new,/*.uninit=*/msandroid_sound_uninit,/*.duplicate=*/msandroid_sound_duplicate};

for循环内，ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);在mssndcard.c line 142;

void ms_snd_card_manager_register_desc(MSSndCardManager *m, MSSndCardDesc *desc){         if (bctbx_list_find(m->descs, desc) == NULL){                m->descs=bctbx_list_append(m->descs,desc);                card_detect(m,desc);        }}

遍历每个ms_snd_card_descs中的desc，并执行card_detect(m，desc);

static void card_detect(MSSndCardManager *m, MSSndCardDesc *desc){        if (desc->detect!=NULL)            desc->detect(m);}

只是执行desc->detect(m)；
已知Android平台有三种声卡，所以这里会执行每个声卡描述的detect函数；

对于android_native_snd_card_desc，在执行desc->detect（m）的时候，实质上就是执行了android_native_snd_card_desc中定义的的detect函数
android_snd_card_detect(m)，在androidsound.cpp中.

static void android_snd_card_detect(MSSndCardManager *m) {   ms_message("android_snd_card_detect");   bool audio_record_loaded = false;   bool audio_track_loaded = false;   bool audio_system_loaded = false;   bool string8_loaded = false;   bool refbase_loaded = false;   SoundDeviceDescription *d = NULL;   MSDevicesInfo *devices = NULL;   if (get_sdk_version() > 19) {      /*it is actually working well on android 5 on Nexus 4 but crashes on Samsung S5, due to, maybe       * calling convention of C++ method being different. Arguments received by AudioTrack constructor do not match the arguments       * sent by the caller (TransferType maps to uid argument!).       * Until we find a rational explanation to this, the native module is disabled on Android 5.      **/      ms_message("Native android sound support not tested on SDK [%i], disabled.",get_sdk_version());      return;   }   devices = ms_factory_get_devices_info(m->factory);   d = ms_devices_info_get_sound_device_description(devices);   if (d->flags & DEVICE_HAS_UNSTANDARD_LIBMEDIA){      ms_message("Native android sound support is blacklisted for this device.");      return;   }   /* libmedia and libutils static variable may survive to Linphone restarts    It is then necessary to perform the *::init() calls even if the libmedia and libutils are there.*/   if (!libmedia) libmedia=Library::load("/system/lib/libmedia.so");   if (!libutils) libutils=Library::load("/system/lib/libutils.so");   if (libmedia && libutils) {      /*perform initializations in order rather than in a if statement so that all missing symbols are shown in logs*/      string8_loaded = String8Impl::init(libutils);      refbase_loaded = RefBaseImpl::init(libutils);      audio_record_loaded = AudioRecordImpl::init(libmedia);      audio_track_loaded = AudioTrackImpl::init(libmedia);      audio_system_loaded = AudioSystemImpl::init(libmedia);   }   if (audio_record_loaded && audio_track_loaded && audio_system_loaded && string8_loaded && refbase_loaded) {      ms_message("Native android sound support available.");      MSSndCard* card = android_snd_card_new(d);      ms_snd_card_set_manager(m, card);      ms_snd_card_manager_add_card(m, card);      return;   }   ms_message("Native android sound support is NOT available.");}

• 首先会判断系统sdk版本，如果19以上的android系统，直接跳过，不使用这个声卡模型，给出的解释是，Android5上面的native
  module is disabled；
• 19以下的版本才会使用这个声卡模型：加载需要使用的媒体库，使用的是system/lib下的libmedia.so，这个很关键；
• 然后使用这个libmedia.so初始化三个媒体
  AudioRecordImpl、AudioTrackImpl、AudioSystemImpl的init;
• 然后构建真实的声卡模型对象，android_snd_card_new(d)，每个声卡模型都有自己的android_snd_card_new函数；

static MSSndCard * android_snd_card_new(SoundDeviceDescription *d){        MSSndCard * obj;                        obj=ms_snd_card_new(&android_native_snd_card_desc);        obj->name=ms_strdup("android sound card");          if (d->flags & DEVICE_HAS_BUILTIN_AEC) obj->capabilities|=MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER;        obj->latency=d->delay;        obj->data = new AndroidNativeSndCardData(  d->recommended_rate, d->flags);        return obj;}

对于android_native_snd_opensles_card_desc，在执行desc->detect（m）的时候，实质上就是执行了android_native_snd_opensles_card_desc中定义的的detect函数 android_snd_card_detect， 在androidsound_opensles.cpp中

static void android_snd_card_detect(MSSndCardManager *m) {        SoundDeviceDescription* d = NULL;        MSDevicesInfo *devices = NULL;        if (initOpenSLES() == 0) { // Try to dlopen libOpenSLES                ms_message("libOpenSLES correctly loaded, creating OpenSLES MS soundcard");                devices = ms_factory_get_devices_info(m->factory);                  d = ms_devices_info_get_sound_device_description(devices);                 if (d->flags & DEVICE_HAS_CRAPPY_OPENSLES)                        return;                 MSSndCard *card = android_snd_card_new(m);                ms_snd_card_manager_add_card(m, card);        } else {                ms_warning("Failed to dlopen libOpenSLES, OpenSLES MS soundcard unavailable");         }}   

同样的，该类下也有android_snd_card_new方法，

static MSSndCard* android_snd_card_new(MSSndCardManager *m) {            MSSndCard* card = NULL;            SoundDeviceDescription *d = NULL;            MSDevicesInfo *devices = NULL;            card = ms_snd_card_new(&android_native_snd_opensles_card_desc);            card->name = ms_strdup("android sound card");            devices = ms_factory_get_devices_info(m->factory);            d = ms_devices_info_get_sound_device_description(devices);            OpenSLESContext *context = opensles_context_init();            if (d->flags & DEVICE_HAS_BUILTIN_OPENSLES_AEC) {                    card->capabilities |= MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER;                    context->builtin_aec = true;            } else if (d->flags & DEVICE_HAS_BUILTIN_AEC) {                    ms_warning("Removing MS_SND_CARD_CAP_CAPTURE flag from soundcard to use HAEC Java capture soundcard");                    card->capabilities = MS_SND_CARD_CAP_PLAYBACK;            }            card->latency = d->delay;            card->data = context;               if (d->recommended_rate){                    context->samplerate = d->recommended_rate;             }             return card;}

对于msandroid_sound_card_desc，在执行desc->detect（m）的时候，实质上就是执行了msandroid_sound_card_desc中定义的的detect函数msandroid_sound_detect，

void msandroid_sound_detect(MSSndCardManager *m) {            ms_message("msandroid_sound_detect");            MSSndCard *card = msandroid_sound_card_new(m);             ms_snd_card_manager_add_card(m, card);}

MSSndCard *msandroid_sound_card_new(MSSndCardManager *m) {                ms_message("msandroid_sound_card_new");            SoundDeviceDescription *d = NULL;                MSDevicesInfo *devices = NULL;            MSSndCard *card = ms_snd_card_new(&msandroid_sound_card_desc);            card->name = ms_strdup("Android Sound card");            devices = ms_factory_get_devices_info(m->factory);            d = ms_devices_info_get_sound_device_description(devices);             if (d->flags & DEVICE_HAS_BUILTIN_AEC) {                    card->capabilities |= MS_SND_CARD_CAP_BUILTIN_ECHO_CANCELLER;            }            card->data = d;             return card;}

三种声卡都会设置capabilities属性，这个属性主要是决定这个声卡是做为播放器使用还是录音器使用，取值不一样，这里三种声卡的capabilities取值为3，表示既可以作为录音器也可以作为播放器
三种MSSndCardDesc*的detect最终都是调用ms_snd_card_new（MSSndCardDesc*）来实现的；

该函数在mssndcard.c中，line171

MSSndCard * ms_snd_card_new(MSSndCardDesc *desc){        return ms_snd_card_new_with_name(desc,NULL);}

MSSndCard * ms_snd_card_new_with_name(MSSndCardDesc *desc,const char* name) {        ms_message("ms_snd_card_new_with_name %s",desc->driver_type);        MSSndCard *obj=(MSSndCard *)ms_new0(MSSndCard,1);        obj->sndcardmanager = NULL;        obj->desc=desc;         obj->name=name?ms_strdup(name):NULL;        obj->data=NULL;        obj->id=NULL;        obj->capabilities=MS_SND_CARD_CAP_CAPTURE|MS_SND_CARD_CAP_PLAYBACK;        if (desc->init!=NULL)                desc->init(obj);        return obj;}

执行各个desc->init();
对于android_native_snd_card_desc和android_native_snd_opensles_card_desc，init是个空函数，msandroid_sound_card_desc内有init函数；

void msandroid_sound_init(MSSndCard *card){        /*get running sdk version*/        JNIEnv *jni_env = ms_get_jni_env();        jclass version_class = jni_env->FindClass("android/os/Build$VERSION");        jfieldID fid = jni_env->GetStaticFieldID(version_class, "SDK_INT", "I");        sdk_version=jni_env->GetStaticIntField(version_class, fid);         ms_message("SDK version [%i] detected",sdk_version);        jni_env->DeleteLocalRef(version_class);}

对于三种不同的声卡模型，执行ms_snd_card_new生成MSSndCard模型对象以后，都会通过ms_snd_card_manager_add_card()；来完成MSSndCardManager对象和MSSndCard对象的相互关联

ms_snd_card_manager_add_card() 位于mssndcard.c Line119

void ms_snd_card_manager_add_card(MSSndCardManager *m, MSSndCard *c){    ms_snd_card_set_manager(m,c);    ms_message("Card '%s' added with capabilities [%s]",ms_snd_card_get_string_id(c), cap_to_string(c->capabilities));    m->cards=bctbx_list_append(m->cards,c);}void ms_snd_card_set_manager(MSSndCardManager*m, MSSndCard *c){    if (c->sndcardmanager == NULL) c->sndcardmanager = m;}

操作比较简单，首先将给每个MSSndCard对象设置->sndcardmanager属性为MSSndCardManager对象；
然后将声卡模型对象追加到MSSndCardManager对象的cards列表里；
至此ms_factory_init_voip全部结束。

简单总结一下：

• **初始化首先构建一个声卡模型对象管理者 MSSndCardManager对象，并与传入的MSFactory互相关联
  factory->sndcardmanager = sndcardManager;
  sndcardManager->factory =factory;**
• **然后系统自身配置了一个声卡模型描述的数组，定义了三种不同的声卡模型；
  android_native_snd_card_desc;
  android_native_snd_opensles_card_desc;
  msandroid_sound_card_desc;**
• **通过调用模型中定义的detect函数和init函数指针来构建MSSndCard模型对象，并且与MSSndCardManager对象相互关联；
  sndcard->sndcardmanager = sndcardmanager;
  sndcardmanager->cards =bctbx_list_append(sndcard)；**
• 最终返回MSFactory模型；

需要注意的是，sndcardmanager->cards中存放的声卡模型列表是按先后顺序存放的，这点很重要，因为后面再读取音频配置的手，会根据id和capability来选择匹配的声卡，并且是返回第一个匹配的；

第三步，ms_factory_init_plugins(f)； 位于msfactory.c line672;

void ms_factory_init_plugins(MSFactory *obj) {   if (obj->plugins_dir == NULL) {#ifdef PACKAGE_PLUGINS_DIR      obj->plugins_dir = ms_strdup(PACKAGE_PLUGINS_DIR);#else      obj->plugins_dir = ms_strdup("");#endif   }   if (strlen(obj->plugins_dir) > 0) {      ms_message("Loading ms plugins from [%s]",obj->plugins_dir);      ms_factory_load_plugins(obj,obj->plugins_dir);       }}

因为MSFactory是刚新建并初始化的，这里他的plugins_dir还没有值；
这里预定义了一个PACKAGE_PLUGINS_DIR字符串，赋值给factory->plugins_dir；

ms_factory_load_plugins();在msfactory.c line467中；从log来看， 这里指定的plugins_dir路径不存在，结果返回了-1;
至此 ms_factory_new_with_voip()全部结束。

回到linphone_core_init中 ，函数内部最后有一段

    remote_provisioning_uri = linphone_core_get_provisioning_uri(lc)；    if(remote_provisioning_uri == NULL){        linphone_configuring_terminated(lc,LinphoneConfiguringSkipped,NULL)    }

linphone_core_get_provisioning_uri() 位于remote_provisioning.c line157

const char*linphone_core_get_provisioning_uri(const LinphoneCore *lc){      return lp_config_get_string(lc->config,"misc","config-uri",NULL);}

从系统配置文件中读取misc下的config-uri字段。
系统默认的配置文件中没有设置这个字段，顾返回的是NULL；
因而继续执行linphone_configuring_terminated()， 位于linphonecore.c line1670;

void linphone_configuring_terminated(LinphoneCore *lc, LinphoneConfiguringState state, const char *message) {    ms_message("linphone_configuring_terminated");    linphone_core_notify_configuring_status(lc, state, message);    if (state == LinphoneConfiguringSuccessful) {             if (linphone_core_is_provisioning_transient(lc) == TRUE)            linphone_core_set_provisioning_uri(lc, NULL);    }    if (lc->provisioning_http_listener){            belle_sip_object_unref(lc->provisioning_http_listener);             lc->provisioning_http_listener = NULL;    }    linphone_core_start(lc);}

首先更新状态为LinphoneConfiguringSkipped；linphone_core_notify_configuring_status位于vtables.c line264

void linphone_core_notify_configuring_status(LinphoneCore *lc, LinphoneConfiguringState status, const char *message) {    NOTIFY_IF_EXIST(configuring_status, lc,status,message);    cleanup_dead_vtable_refs(lc);}

通过NOTIFY_IF_EXIST宏，去在vtables中找configuring_status是否有对应的回调函数，并执行对应的回调通知java层状态变化；
剩下的两步操作应该都不存在，直接进入linphone_core_start(lc)；位于linphonecore.c line1640；

static void linphone_core_start(LinphoneCore * lc) {    ms_message("linphone_core_start");    LinphoneFriendList *list = linphone_core_create_friend_list(lc);    linphone_friend_list_set_display_name(list, "_default");    linphone_core_add_friend_list(lc, list);     linphone_friend_list_unref(list);     sip_setup_register_all(lc->factory);     sound_config_read(lc);     net_config_read(lc);     rtp_config_read(lc);    codecs_config_read(lc);    sip_config_read(lc);    video_config_read(lc);    //autoreplier_config_init(&lc->autoreplier_conf);    lc->presence_model=linphone_presence_model_new_with_activity(LinphonePresenceActivityOnline, NULL);    misc_config_read(lc);    ui_config_read(lc);    #ifdef TUNNEL_ENABLED        if (lc->tunnel) {                 linphone_tunnel_configure(lc->tunnel);        }    #endif     linphone_core_notify_display_status(lc,_("Ready"));     lc->auto_net_state_mon=lc->sip_conf.auto_net_state_mon;    linphone_core_set_state(lc,LinphoneGlobalOn,"Ready");}

关于声卡的配置在sound_config_read中，linphonecore.c line825

static void sound_config_read(LinphoneCore *lc){        ms_message("sound_config_read");    int tmp;    const char *tmpbuf;    const char *devid;    #ifdef __linux        /*alsadev let the user use custom alsa device within linphone*/         devid=lp_config_get_string(lc->config,"sound","alsadev",NULL);        if (devid){             ...                for (l=0,i=strpbrk(d+l,delim);i;i=strpbrk(d+l,delim)){                    char s=*i;                    *i='\0';                    card=ms_alsa_card_new_custom(d+l,d+l);                    ms_snd_card_manager_add_card(ms_factory_get_snd_card_manager(lc->factory),card);                    *i=s;                    l=i-d+1;                }            ...        }        tmp=lp_config_get_int(lc->config,"sound","alsa_forced_rate",-1);        if (tmp>0) ms_alsa_card_set_forced_sample_rate(tmp);    #endif      /* retrieve all sound devices */    build_sound_devices_table(lc);    devid=lp_config_get_string(lc->config,"sound","playback_dev_id",NULL);    linphone_core_set_playback_device(lc,devid);    devid=lp_config_get_string(lc->config,"sound","ringer_dev_id",NULL);     linphone_core_set_ringer_device(lc,devid);    devid=lp_config_get_string(lc->config,"sound","capture_dev_id",NULL);    linphone_core_set_capture_device(lc,devid);    ... }

这个函数主要的操作是通过读取lc->config中关于sound的配置字段，然后进行相关的设置操作；
按顺序进行一下检查配置：

1. 检查是或否存在alsadev字段，如果存在的话，通过ms_alsa_card_new_custom新建一个MSSndCard，并添加到lc->factory->mssndcardmanager;
2. build_sound_devices_table(lc)，从lc中读取mssndcardmanager中的声卡模型列表，并重新定义一个字符串数组，保存这些声卡的driver_type值；
   然后将数组保存到lc->sound_conf.cards中；
3. 读取lc->config中sound字段下的playback_dev_id值，并调用linphone_core_set_playback_device设置,这是播放器声卡
4. 读取lc->config中sound字段下的ringer_dev_id值，并调用linphone_core_set_ringer_device设置；
5. 读取lc->config中sound字段下的capture_dev_id值，并调用linphone_core_set_capture_device设置，这是录音器声卡
6. 后面依次设置sound下的local_ring、remot_ring、hold_music、echocancelllation、echolimiter、agc等其他相关配置
7. _linphone_core_set_tone，设置遇忙情况下的响铃，保存在lc->tones中；

重点分析一下第2~5步的操作

第二步：build_sound_devices_table(lc)，位于linphonecore.c line794;

static void build_sound_devices_table(LinphoneCore *lc){    const char **devices;    const char **old;    size_t ndev;    int i;      const bctbx_list_t *elem=ms_snd_card_manager_get_list(ms_factory_get_snd_card_manager(lc->factory));    ndev=bctbx_list_size(elem);     devices=ms_malloc((ndev+1)*sizeof(const char *));    for (i=0;elem!=NULL;elem=elem->next,i++){            devices[i]=ms_snd_card_get_string_id((MSSndCard *)elem->data);            ms_message("build sound devices table %i = %s",i,devices[i]);    }    devices[ndev]=NULL;    old=lc->sound_conf.cards;    lc->sound_conf.cards=devices;    if (old!=NULL) ms_free((void *)old); }

第三步：播放器的设置
系统默认的配置文件中是没有定义playback_dev_id的，linphone_core_set_playback_device中的第二个入参实际是null;函数位于
linphonecore.c line4812;

int linphone_core_set_playback_device(LinphoneCore *lc, const char * devid){    ms_message("linphone_core_set_playback_device  %s",devid);    MSSndCard *card=get_card_from_string_id(devid,MS_SND_CARD_CAP_PLAYBACK, lc->factory);    lc->sound_conf.play_sndcard=card;    if (card &&  linphone_core_ready(lc))             lp_config_set_string(lc->config,"sound","playback_dev_id",ms_snd_card_get_string_id(card));    return 0;}

通过传入的id和MS_SND_CARD_CAP_PLAYBACK类型，从lc->factory中读取对应的声卡模型；
然后将这个声卡模型设置给lc->sound_conf.play_sndcard；
并且将这个声卡的id设置到系统配置lc->config中；

简单看一下get_card_from_string_id()这个函数，位于linphonecore.c line4738中；

static MSSndCard *get_card_from_string_id(const char *devid, unsigned int cap, MSFactory *f){    MSSndCard *sndcard=NULL;    if (devid!=NULL){            sndcard=ms_snd_card_manager_get_card(ms_factory_get_snd_card_manager(f),devid);            if (sndcard!=NULL &&(ms_snd_card_get_capabilities(sndcard) & cap)==0 ){                 sndcard=NULL;            }    }     if (sndcard==NULL) {             if ((cap & MS_SND_CARD_CAP_CAPTURE) && (cap & MS_SND_CARD_CAP_PLAYBACK)){                sndcard=ms_snd_card_manager_get_default_card(ms_factory_get_snd_card_manager(f));            }else if (cap & MS_SND_CARD_CAP_CAPTURE){                 sndcard=ms_snd_card_manager_get_default_capture_card(ms_factory_get_snd_card_manager(f));            }            else if (cap & MS_SND_CARD_CAP_PLAYBACK){                sndcard=ms_snd_card_manager_get_default_playback_card(ms_factory_get_snd_card_manager(f));               }             if (sndcard==NULL){/*looks like a bug! take the first one !*/                const bctbx_list_t *elem=ms_snd_card_manager_get_list(ms_factory_get_snd_card_manager(f));                 if (elem) sndcard=(MSSndCard*)elem->data;             }    }    if (sndcard==NULL) ms_error("Could not find a suitable soundcard !");    return sndcard;}

• 如果入参devid有值，就通过ms_snd_card_manager_get_card来查找id相同的MSSndCard，同时检查一下这个声卡的capability是否与入参中的cap一致；
• 如果id相同、capability不一致，也重新查找；
• 根据入参的Cap来选择不同的查找方式，这里我们用的是MS_SND_CARD_CAP_PLAYBACK的类别；

所以选择ms_snd_card_manager_get_default_playback_card(manager); 函数位于 mssndcard.c line100；

MSSndCard * ms_snd_card_manager_get_default_playback_card(MSSndCardManager *m){    return get_card_with_cap(m, NULL, MS_SND_CARD_CAP_PLAYBACK);}static MSSndCard *get_card_with_cap(MSSndCardManager *m, const char *id, unsigned int caps){    bctbx_list_t *elem;     for (elem=m->cards;elem!=NULL;elem=elem->next){             MSSndCard *card=(MSSndCard*)elem->data;             if ((id== NULL || strcmp(ms_snd_card_get_string_id(card),id)==0) && (card->capabilities & caps) == caps)   return card;     }    return NULL;}

其实这里的获取方式也是根据cap和id来的，如果有id值，则返回同时匹配的声卡， 如果没有id值，则返回cap匹配的声卡；

需要注意的是，这里只要匹配到第一个满足条件的声卡模型，就返回了，所以如果存放的顺序也决定了linphone最终选择使用何种声卡；

第五步： 录音器的设置
同样的，系统默认的配置中没有指定capture_dev_id，整个流程与播音器的设置基本一致；
linphone_core_set_capture_device（） 位于linphonecore.c line4831

int linphone_core_set_capture_device(LinphoneCore *lc, const char * devid){    MSSndCard *card=get_card_from_string_id(devid,MS_SND_CARD_CAP_CAPTURE, lc->factory);    lc->sound_conf.capt_sndcard=card;    if (card &&  linphone_core_ready(lc))            lp_config_set_string(lc->config,"sound","capture_dev_id",ms_snd_card_get_string_id(card));     return 0;}

将读取到的声卡设置到lc->sound_conf.capt_sndcard中；

后面的操作不细看了，到这里linphone使用的录音器和播放器全部设置好了；

**后续再音频、视屏通话的时候，启动录音器就是通过lc->sound_conf.capt_sndcard来获取对应的声卡模型；
然后调用模型中定义的函数接口来获取录音数据；**