Linphone 源码静态分析

1，Linphone初始化工作;
    入口：linphone_core_new(...) -->linphone_core_init(core,vtable,config_path, factory_config_path, userdata);
   I，首先就是与oRTP(基于RFC3550的一个实现)协议栈相关的初始化操作：如：ortp_init()；
    在这个函数里面做的工作有:
     [A]av_profile_init()即负载类型的初始化。rtp最大支持128种负载类型。这里有个概念：
     RtpProfile：

     * The RTP profile is a table RTP_PROFILE_MAX_PAYLOADS entries to make the matching
     * between RTP payload type number and the PayloadType that defines the type of
     * media.
    [B]rtp全局统计信息初始化

    typedef struct rtp_stats
    {
        uint64_t packet_sent;
        uint64_t sent;        /* bytes sent */
        uint64_t recv;         /* bytes of payload received and delivered in time to the application */
        uint64_t hw_recv;        /* bytes of payload received */
        uint64_t packet_recv;    /* number of packets received */
        uint64_t outoftime;        /* number of packets that were received too late */
        uint64_t cum_packet_loss; /* cumulative number of packet lost */
        uint64_t bad;            /* packets that did not appear to be RTP */
        uint64_t discarded;        /* incoming packets discarded because the queue exceeds its max size */
        uint64_t sent_rtcp_packets;    /* sent RTCP packets counter (only packets that embed a report block are considered) */
    } rtp_stats_t;

   接下来是Linphone所用到的一些负载类型的初始话（assign）,包括音频，视频的，与number相关的及无关的两类；

  II， 其次是mediastream2的一些初始化。ms_init();
        包括日志相关的设置，ortp_set_log_level_mask(ORTP_MESSAGE|ORTP_WARNING|ORTP_ERROR|ORTP_FATAL);
                ortp_set_log_handler(ms_android_log_handler);
        Filter初始化/注册：
            /* register builtin MSFilter's */
            for (i=0;ms_filter_descs[i]!=NULL;i++){
                ms_filter_register(ms_filter_descs[i]);
            }
        声卡初始化，
            cm=ms_snd_card_manager_get();
            for (i=0;ms_snd_card_descs[i]!=NULL;i++){
                ms_snd_card_manager_register_desc(cm,ms_snd_card_descs[i]);
            }
        网络摄像头的初始化，
            MSWebCamManager *wm;
            wm=ms_web_cam_manager_get();
            for (i=0;ms_web_cam_descs[i]!=NULL;i++){
                ms_web_cam_manager_register_desc(wm,ms_web_cam_descs[i]);
            }
        绘制视频图像初始化（opengl）:
            libmsandroidopengldisplay_init();

    还要初始化一个mediastream2的事件队列：ms_event_queue_new（）；
    
    III，再次就是初始化一个很重要的结构体对象：

    struct Sal{
        SalCallbacks callbacks;
        MSList *calls; /*MSList of SalOp */
        MSList *registers;/*MSList of SalOp */
        MSList *out_subscribes;/*MSList of SalOp */
        MSList *in_subscribes;/*MSList of SalOp */
        MSList *pending_auths;/*MSList of SalOp */
        MSList *other_transactions; /*MSList of SalOp */
        int running;
        int session_expires;
        int keepalive_period;
        void *up;
        bool_t one_matching_codec;
        bool_t double_reg;
        bool_t use_rports;
        bool_t use_101;
        bool_t reuse_authorization;
        char* rootCa; /* File _or_ folder containing root CA */
    };
    这个对象很重要，在全局只有一个。是sip信号处理抽象层；初始化它的同时进行exosip的初始化：eXosip_init();
    并设置协议信号处理回调函数结构体对象：linphone_sal_callbacks，用以处理各种sip消息。

   IV，最后就是初始化一些配置信息：
    sip_setup_register_all(); //linphone_sip_login 【注册上去】。
    sound_config_read(lc);
    net_config_read(lc);
    rtp_config_read(lc);
    codecs_config_read(lc);
    sip_config_read(lc); /* this will start eXosip*/
        IP，端口，协议配置。
        linphone_core_set_sip_transports(lc,&tr);监听
        sal_root_ca();认证
        代理配置信息：lc->sip_conf.proxies
        默认代理：linphone_core_set_default_proxy_index();
        授权信息：
            /* read authentication information */
            for(i=0;; i++){
                LinphoneAuthInfo *ai=linphone_auth_info_new_from_config_file(lc->config,i);
                if (ai!=NULL){
                    linphone_core_add_auth_info(lc,ai);
                    linphone_auth_info_destroy(ai);
                }else{
                    break;
                }
            }
        其它配置信息：/*for tuning or test*/等等。。。


    }
    video_config_read(lc);

   Linphone 进入“Read” 状态。。。。。。


2，注册到服务器的过程。
    
    在linphone_core_iterate()中     proxy_update(lc); 就是注册的触发函数，依次循环每个代理配置，判断commit=true && reg_sendregistry = true;
    I,linphone_proxy_config_activate_sip_setup:激活一个sipsetup环境
    II,linphone_proxy_config_register(LinphoneProxyConfig *cfg);生成一个用于注册的SalOp,并设置其contact和
    user_pointer 如:
        sal_op_set_contact(obj->op,contact);
        ms_free(contact);
        sal_op_set_user_pointer(obj->op,obj);
    然后发出注册消息：sal_register(obj->op,obj->reg_proxy,obj->reg_identity,obj->expires)，开始了注册过程...
        首次注册没有授权信息，所以会失败,收到sip消息： EXOSIP_REGISTRATION_FAILURE:
    case 401:case 407:process_authentication(sal,ev);就会提出授权要求(有sip信号处理回调函数来处理)：auth_requested，并添加到：op->pending_auth=ev;
    如果其它原因的错误就需要其它的处理了。比如case 423:case 606,当用户收到授权请求时，就会判断当前的授权信息是否满足,
    LinphoneAuthInfo *ai=(LinphoneAuthInfo*)linphone_core_find_auth_info(lc,realm,username)；然后给注册操作授权：sal_op_authenticate(h,&sai);
    如果当前没有满足的授权信息，则可能需要用户输入授权信息。。。。
    
    如果注册成功：则需要首先提示授权工作了authentication_ok(sal,ev)。再确定回应里面的请求-是否需要重新注册新的contact.(register_again_with_updated_contact),
    如果需要，就重新注册，update_contact_from_response(op,last_answer);contact do not match, need to update the register ？？。。。。
    不需要的话，就可以提示注册成功的消息了。至此，注册完毕；

3，一次呼叫建立的过程(重点,内容很多呀...)；

    LinphoneCall * linphone_core_invite(LinphoneCore *lc, const char *url) ：
    LinphoneCall * linphone_core_invite(LinphoneCore *lc, const char *url);
    LinphoneCall * linphone_core_invite_address(LinphoneCore *lc, const LinphoneAddress *addr);
    LinphoneCall * linphone_core_invite_with_params(LinphoneCore *lc, const char *url, const LinphoneCallParams *params);
    LinphoneCall * linphone_core_invite_address_with_params(LinphoneCore *lc, const LinphoneAddress *addr, const LinphoneCallParams *params);
    四个出发函数。最终要依赖linphone_core_invite_address_with_params，中间可能多一些地址转换，呼叫参数（如是否支持视频等）的初始化工作。
    进入到呼叫函数linphone_core_invite_address_with_params后，首先判断当前是否有呼叫，以及是否达到呼叫数目的最大限。
    linphone_core_in_call(lc)；
    linphone_core_can_we_add_call(lc)；
    接这对默认代理，和呼叫地址中的代理进行匹配，如果不一样，则进行重写默认的代理，以呼叫地址中的代理为准。生成一个from字符串。
    如果都为空则from=linphone_core_get_primary_contact(lc);/* if no proxy or no identity defined for this proxy, default to primary contact*/
    生成URL：parsed_url2=linphone_address_new(from);创建一个新的Call:
    call=linphone_call_new_outgoing(lc,parsed_url2,linphone_address_clone(addr),params);里面包括一些设置：
        
        linphone_core_get_local_ip(lc,linphone_address_get_domain(to),call->localip);
        linphone_call_init_common(call,from,to);//在这里计数：refcnt=1,设置引用基数.
        call->params=*params;
        call->localdesc=create_local_media_description (lc,call);   //本地媒体类型描述
        call->camera_active=params->has_video;
        if (linphone_core_get_firewall_policy(call->core)==LinphonePolicyUseStun)
            linphone_core_run_stun_tests(call->core,call);  //防火墙策略
        discover_mtu(lc,linphone_address_get_domain (to));
        if (params->referer){
            sal_call_set_referer (call->op,params->referer->op); //是呼叫转移吗
        }
    
    设置route:sal_op_set_route(call->op,route);添加到LinphoneCore:linphone_core_add_call(lc,call),然后lc->current_call=call;
    接下来，如果需要ping
       就可以直接进行呼叫了：linphone_core_start_invite(lc,call,dest_proxy);不然就接着进行ping操作：
    if (dest_proxy!=NULL || lc->sip_conf.ping_with_options==FALSE){
        linphone_core_start_invite(lc,call,dest_proxy);
    }else{
        /*defer the start of the call after the OPTIONS ping*/
        call->ping_op=sal_op_new(lc->sal);
        sal_ping(call->ping_op,from,real_url); ///ping操作，，，eXosip_options_build_request -->...--> eXosip_options_send_request(options);
        sal_op_set_user_pointer(call->ping_op,call);
        call->start_time=time(NULL);
    }
    
    linphone_core_iterator里面如果curtime-call->start_time>=2，则会不等ping回来，就呼叫linphone_core_start_invite(lc,call,NULL);
    
    如果需要ping操作，就需要处理Ping_op的回应，消息处理函数是：other_request_reply(sal,ev);
    -->sal->callbacks.ping_reply(op);在ping_reply里面：linphone_core_start_invite(call->core,call,NULL);
    至此，终于可以进行呼叫了。当对初始化了的call进行，真正呼叫时要什么呢？
    I，为呼叫操作设置contact,sal_op_set_contact(call->op, contact);而这里的contact是从get_fixed_contact(lc,call,dest_proxy)，即dest_proxy而来的。
    II，linphone_call_init_media_streams(call);初始化音频，视频的媒体流，
        第一部分：初始化 audio_stream_new ，统计信息初始化：ms_filter_enable_statistics(TRUE);ms_filter_reset_statistics();
            创建配置session:stream->session=create_duplex_rtpsession(locport,ipv6);//RTP_SESSION_SENDRECV 模式的
            rtpr=rtp_session_new(RTP_SESSION_SENDRECV);[[[===
                    rtp_session_set_recv_buf_size(rtpr,MAX_RTP_SIZE);
                    rtp_session_set_scheduling_mode(rtpr,0);
                    rtp_session_set_blocking_mode(rtpr,0);
                    rtp_session_enable_adaptive_jitter_compensation(rtpr,TRUE);
                    rtp_session_set_symmetric_rtp(rtpr,TRUE);
                    rtp_session_set_local_addr(rtpr,ipv6 ? "::" : "0.0.0.0",locport);
                    rtp_session_signal_connect(rtpr,"timestamp_jump",(RtpCallback)rtp_session_resync,(long)NULL);
                    rtp_session_signal_connect(rtpr,"ssrc_changed",(RtpCallback)rtp_session_resync,(long)NULL);
                    rtp_session_set_ssrc_changed_threshold(rtpr,0);
                    rtp_session_set_rtcp_report_interval(rtpr,2500); /*at the beginning of the session send more reports*/
                    disable_checksums(rtp_session_get_rtp_socket(rtpr));
            添加发送的filter:stream->rtpsend=ms_filter_new(MS_RTP_SEND_ID);
            添加回声消除的filter:stream->ec=ms_filter_new_from_desc(ec_desc);
            生成并初始化，为本stream注册rtp事件队列：stream->evq=ortp_ev_queue_new();rtp_session_register_event_queue(stream->session,stream->evq);
            其它初始化：stream->play_dtmfs=TRUE;
                stream->use_gc=FALSE;
                stream->use_agc=FALSE;
                stream->use_ng=FALSE;
            ===]]]

            接着，如果支持回声限制,则根据配置信息设置一些相关参数，如：audio_stream_enable_echo_limiter(audiostream,ELControlFull);
            接着，如果支持回声消除,则根据配置信息设置一些相关参数，如：audio_stream_set_echo_canceller_params；
            接着，是否支持获取控制，以便不获取噪声，有个噪声的gateway要设置:
            int enabled=lp_config_get_int(lc->config,"sound","noisegate",0);
            audio_stream_enable_noise_gate(audiostream,enabled);

            在就是为session设置if (lc->a_rtp) rtp_session_set_transports(audiostream->session,lc->a_rtp,lc->a_rtcp);
            给Call也注册一个ort事件队列：call->audiostream_app_evq = ortp_ev_queue_new();
                        rtp_session_register_event_queue(audiostream->session,call->audiostream_app_evq);
        第二部分：如果支持视频，则需要call->videostream=video_stream_new(md->streams[1].port,linphone_core_ipv6_enabled(lc));//初始化视频流
            具体：VideoStream *stream = (VideoStream *)ms_new0 (VideoStream, 1);
                stream->session=create_duplex_rtpsession(locport,use_ipv6);
                stream->evq=ortp_ev_queue_new();
                stream->rtpsend=ms_filter_new(MS_RTP_SEND_ID);
                rtp_session_register_event_queue(stream->session,stream->evq);
                stream->sent_vsize.width=MS_VIDEO_SIZE_CIF_W;
                stream->sent_vsize.height=MS_VIDEO_SIZE_CIF_H;
                stream->dir=VideoStreamSendRecv;
                choose_display_name(stream);
              
            接下来：设置display_filter_name，设置video_stream_set_event_callback,设置rtp_session_set_transports,
            注册rtp事件队列:rtp_session_register_event_queue(call->videostream->session,call->videostream_app_evq);
            
    III，sal_call_set_local_media_description ,设置本地媒体格式描述。
    解析地址from ,url,等，然后开始真正呼叫。。err=sal_call(call->op,from,real_url);具体展开。。。：
        
            int sal_call(SalOp *h, const char *from, const char *to){
            int err;
            osip_message_t *invite=NULL;
            sal_op_set_from(h,from);
            sal_op_set_to(h,to);
            sal_exosip_fix_route(h);
            err=eXosip_call_build_initial_invite(&invite,to,from,sal_op_get_route(h),"Phone call");
            if (err!=0){
                ms_error("Could not create call.");
                return -1;
            }
            osip_message_set_allow(invite, "INVITE, ACK, CANCEL, OPTIONS, BYE, REFER, NOTIFY, MESSAGE, SUBSCRIBE, INFO");
            if (h->base.contact){
                _osip_list_set_empty(&invite->contacts,(void (*)(void*))osip_contact_free);
                osip_message_set_contact(invite,h->base.contact);
            }
            if (h->base.root->session_expires!=0){
                osip_message_set_header(invite, "Session-expires", "200");
                osip_message_set_supported(invite, "timer");
            }
            if (h->base.local_media){
                h->sdp_offering=TRUE;
                set_sdp_from_desc(invite,h->base.local_media);
            }else h->sdp_offering=FALSE;
            if (h->replaces){
                osip_message_set_header(invite,"Replaces",h->replaces);
                if (h->referred_by)
                    osip_message_set_header(invite,"Referred-By",h->referred_by);
            }
    
            eXosip_lock();
            err=eXosip_call_send_initial_invite(invite);
            eXosip_unlock();
            h->cid=err;
            if (err<0){
                ms_error("Fail to send invite !");
                return -1;
            }else{
                sal_add_call(h->base.root,h);//把操作添加到sal中....
            }
            return 0;
    }

最后设置状态：Contacting。。。

        barmsg=ortp_strdup_printf("%s %s", _("Contacting"), real_url);
        if (lc->vtable.display_status!=NULL)
            lc->vtable.display_status(lc,barmsg);

如此，便开始了等待代理服务器返回消息的状态了。。。。

接下来分析，当接受到对放来的call-request的时候，怎么处理。。。。

        case EXOSIP_CALL_INVITE:表示收到了一个呼叫的消息。执行：inc_new_call(Sal *sal, eXosip_event_t *ev)；
    首先为这个消息生成一个SalOp操作。得到sdp信息：eXosip_get_sdp_info(ev->request);接着从request里面获取一些参数如：origin
ua，replaces，from ,to ,sdp，call_info,tid,cid, did,等等,然后进入sip消息回调里面的call_received回调进行处理，进入这个函数后就是
和主动呼叫(outgoingcall)的模式很相像了，判断收处于呼叫状态，是否达到最大呼叫数目linphone_core_can_we_add_call，有传入的salop得到from
和to，进而判断是否是重复呼叫is_duplicate_call？如果都满足上述条件，就可以惊醒呼叫的创建了：call=linphone_call_new_incoming(lc,from_addr,to_addr,h);
里面包括判决是否发ping指令，本地medaidesc,linphone_call_init_common,create_local_media_description，以及
linphone_core_get_firewall_policy等等。。。，随后开始进行sdp,媒体类型协商：sal_call_get_final_media_description-->sdp_process,
最后添加call,linphone_core_add_call,提示电话来了的消息： lc->vtable.display_status(lc,barmesg); //XX is contacting you?

与此同时，开始ring_start(),播放ringback(/* play the ring if this is the only call*/),
同时发180消息sal_call_notify_ringing(h,propose_early_media || ringback_tone!=NULL);如果自动应答模式，还需接受call.linphone_core_accept_call(lc,call);
具体如下：
【【【---
    sal_call_notify_ringing(h,propose_early_media || ringback_tone!=NULL);//180消息

    if (propose_early_media || ringback_tone!=NULL){
        linphone_call_set_state(call,LinphoneCallIncomingEarlyMedia,"Incoming call early media");
        linphone_core_update_streams(lc,call,md);
    }
    if (sal_call_get_replaces(call->op)!=NULL && lp_config_get_int(lc->config,"sip","auto_answer_replacing_calls",1)){
        linphone_core_accept_call(lc,call);
    }
---】】】



在换回来说吧，当主叫一方收到180Ring的消息后(case EXOSIP_CALL_RINGING),进入到函数：call_ringing(Sal *sal, eXosip_event_t *ev)
首先：call_proceeding(Sal *sal, eXosip_event_t *ev) ---> 
    /* update contact if received and rport are set by the server
     note: will only be used by remote for next INVITE, if any...*/
    update_contact_from_response(op,ev->response);
然后得到sdp:sdp=eXosip_get_sdp_info(ev->response);生成本地的mediadesc,然后协商出一个result md,if (op->base.local_media) sdp_process(op);
回调到sip消息回调处理函数里面sal->callbacks.call_ringing(op);，通知界面，开始early medai,ringing了。。。linphone_core_update_streams,即update一下。

又回去，当被叫决定答应呼叫是，他会调用int linphone_core_accept_call(LinphoneCore *lc, LinphoneCall *call)；
里面会做：I,/* check if this call is supposed to replace an already running one*/replaced=sal_call_get_replaces(call->op);
II,/*try to be best-effort in giving real local or routable contact address*/ --->sal_op_set_contact(call->op,contact);
III,/*stop ringing */-->ring_stop(lc->ringstream);
IV,if (call->audiostream==NULL)
        linphone_call_init_media_streams(call); //这个之前已经做过了，这里只是检查做没做，谨慎期间。

IIV，sal_call_accept(call->op);//发送200OK消息
IIIV，new_md=sal_call_get_final_media_description(call->op);
    linphone_core_update_streams(lc, call, new_md);      //更新媒体流。。。
VI，通知：ms_message("call answered.");


4，
到这里，一个呼叫的整个常规流程也就完事儿了。而整个linphone的主要功能框架也基本完成。但中间一些细节，如如何添加每个节点的filter,如何维持更新媒体流，借助与mediastream2,怎
么实现流媒体的过程，还需进一步分析。（2011-11-10 宣继托）