static void sip_update_within_icoming_reinvite_with_no_sdp(void) {
LinphoneCoreManager *mgr;
char *identity_char;
char *scen;
FILE * sipp_out;
/*currently we use direct connection because sipp do not properly set ACK request uri*/
mgr= linphone_core_manager_new2( "empty_rc", FALSE);
mgr->identity= linphone_core_get_primary_contact_parsed(mgr->lc);
linphone_address_set_username(mgr->identity,"marie");
identity_char=linphone_address_as_string(mgr->identity);
linphone_core_set_primary_contact(mgr->lc,identity_char);
linphone_core_iterate(mgr->lc);
scen = bc_tester_res("sipp/sip_update_within_icoming_reinvite_with_no_sdp.xml");
sipp_out = sip_start(scen, linphone_address_get_username(mgr->identity),NULL, mgr->identity);
if (sipp_out) {
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallIncomingReceived, 1));
linphone_core_accept_call(mgr->lc, linphone_core_get_current_call(mgr->lc));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallStreamsRunning, 2));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallEnd, 1));
pclose(sipp_out);
}
linphone_core_manager_destroy(mgr);
}
static void linphone_vcard_import_export_friends_test(void) {
LinphoneCoreManager* manager = linphone_core_manager_new2("empty_rc", FALSE);
LinphoneFriendList *lfl = linphone_core_get_default_friend_list(manager->lc);
const bctbx_list_t *friends = linphone_friend_list_get_friends(lfl);
char *import_filepath = bc_tester_res("vcards/vcards.vcf");
char *export_filepath = bc_tester_file("export_vcards.vcf");
int count = 0;
BC_ASSERT_EQUAL(bctbx_list_size(friends), 0, int, "%d");
count = linphone_friend_list_import_friends_from_vcard4_file(lfl, import_filepath);
BC_ASSERT_EQUAL(count, 3, int, "%d");
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL(bctbx_list_size(friends), 3, int, "%d");
linphone_friend_list_export_friends_as_vcard4_file(lfl, export_filepath);
lfl = linphone_core_create_friend_list(manager->lc);
count = linphone_friend_list_import_friends_from_vcard4_file(lfl, export_filepath);
BC_ASSERT_EQUAL(count, 3, int, "%d");
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL(bctbx_list_size(friends), 3, int, "%d");
linphone_friend_list_unref(lfl);
remove(export_filepath);
ms_free(import_filepath);
ms_free(export_filepath);
linphone_core_manager_destroy(manager);
}
static void linphone_vcard_import_a_lot_of_friends_test(void) {
LinphoneCoreManager* manager = linphone_core_manager_new2("empty_rc", FALSE);
LinphoneFriendList *lfl = linphone_core_get_default_friend_list(manager->lc);
char *import_filepath = bc_tester_res("vcards/thousand_vcards.vcf");
clock_t start, end;
double elapsed = 0;
const bctbx_list_t *friends = NULL;
FILE *infile = NULL;
char *buffer = NULL;
long numbytes = 0;
size_t readbytes;
start = clock();
linphone_friend_list_import_friends_from_vcard4_file(lfl, import_filepath);
end = clock();
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL((unsigned int)bctbx_list_size(friends), 1000, unsigned int, "%u"); // Now that we accept Friends without a SIP URI, the result must be equal to 1000
elapsed = (double)(end - start);
ms_message("Imported a thousand of vCards from file in %f seconds", elapsed / CLOCKS_PER_SEC);
lfl = linphone_core_create_friend_list(manager->lc);
infile = fopen(import_filepath, "rb");
BC_ASSERT_PTR_NOT_NULL(infile);
if (infile) {
fseek(infile, 0L, SEEK_END);
numbytes = ftell(infile);
fseek(infile, 0L, SEEK_SET);
buffer = (char*)ms_malloc((numbytes + 1) * sizeof(char));
readbytes = fread(buffer, sizeof(char), numbytes, infile);
fclose(infile);
buffer[readbytes] = '\0';
start = clock();
linphone_friend_list_import_friends_from_vcard4_buffer(lfl, buffer);
end = clock();
ms_free(buffer);
}
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL((unsigned int)bctbx_list_size(friends), 1000, unsigned int, "%u"); // Now that we accept Friends without a SIP URI, the result must be equal to 1000
elapsed = (double)(end - start);
ms_message("Imported a thousand of vCards from buffer in %f seconds", elapsed / CLOCKS_PER_SEC);
linphone_friend_list_unref(lfl);
ms_free(import_filepath);
linphone_core_manager_destroy(manager);
}
static void linphone_vcard_import_a_lot_of_friends_test(void) {
LinphoneCoreManager* manager = linphone_core_manager_new2("empty_rc", FALSE);
LinphoneFriendList *lfl = linphone_core_get_default_friend_list(manager->lc);
char *import_filepath = bc_tester_res("vcards/thousand_vcards.vcf");
clock_t start, end;
double elapsed = 0;
const MSList *friends = NULL;
FILE *infile = NULL;
char *buffer = NULL;
long numbytes = 0;
start = clock();
linphone_friend_list_import_friends_from_vcard4_file(lfl, import_filepath);
end = clock();
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL(ms_list_size(friends), 482, int, "%i"); // Thousand vcards contains 482 contacts with a SIP URI
elapsed = (double)(end - start);
ms_error("Imported a thousand of vCards from file (only %i friends with SIP address found) in %f seconds", ms_list_size(friends), elapsed / CLOCKS_PER_SEC);
lfl = linphone_core_create_friend_list(manager->lc);
infile = fopen(import_filepath, "rb");
BC_ASSERT_PTR_NOT_NULL(infile);
if (infile) {
fseek(infile, 0L, SEEK_END);
numbytes = ftell(infile);
fseek(infile, 0L, SEEK_SET);
buffer = (char*)ms_malloc(numbytes * sizeof(char));
numbytes = fread(buffer, sizeof(char), numbytes, infile);
fclose(infile);
start = clock();
linphone_friend_list_import_friends_from_vcard4_buffer(lfl, buffer);
end = clock();
ms_free(buffer);
}
friends = linphone_friend_list_get_friends(lfl);
BC_ASSERT_EQUAL(ms_list_size(friends), 482, int, "%i"); // Thousand vcards contains 482 contacts with a SIP URI
elapsed = (double)(end - start);
ms_error("Imported a thousand of vCards from buffer (only %i friends with SIP address found) in %f seconds", ms_list_size(friends), elapsed / CLOCKS_PER_SEC);
linphone_friend_list_unref(lfl);
ms_free(import_filepath);
linphone_core_manager_destroy(manager);
}
/*static void dest_server_server_resolved(void *data, const char *name, struct addrinfo *ai_list) {
*(struct addrinfo **)data =ai_list;
}*/
static void sip_update_within_icoming_reinvite_with_no_sdp(void) {
LinphoneCoreManager *mgr;
/* LinphoneProxyConfig *proxy = linphone_core_get_default_proxy_config(mgr->lc);
LinphoneAddress *dest = linphone_address_new(linphone_proxy_config_get_route(proxy) ?linphone_proxy_config_get_route(proxy):linphone_proxy_config_get_server_addr(proxy));
struct addrinfo *addrinfo = NULL;
char ipstring [INET6_ADDRSTRLEN];
int err;
int port = linphone_address_get_port(dest);*/
char *identity_char;
char *scen;
FILE * sipp_out;
/*currently we use direct connection because sipp do not properly set ACK request uri*/
mgr= linphone_core_manager_new2( "empty_rc", FALSE);
mgr->identity= linphone_core_get_primary_contact_parsed(mgr->lc);
linphone_address_set_username(mgr->identity,"marie");
identity_char=linphone_address_as_string(mgr->identity);
linphone_core_set_primary_contact(mgr->lc,identity_char);
linphone_core_iterate(mgr->lc);
/*
sal_resolve_a( mgr->lc->sal
,linphone_address_get_domain(dest)
,linphone_address_get_port(dest)
,AF_INET
,(SalResolverCallback)dest_server_server_resolved
,&addrinfo);
linphone_address_destroy(dest);
dest=linphone_address_new(NULL);
wait_for(mgr->lc, mgr->lc, (int*)&addrinfo, 1);
err=getnameinfo((struct sockaddr
*)addrinfo->ai_addr,addrinfo->ai_addrlen,ipstring,INET6_ADDRSTRLEN,NULL,0,NI_NUMERICHOST);
linphone_address_set_domain(dest, ipstring);
if (port > 0)
linphone_address_set_port(dest, port);
*/
scen = bc_tester_res("sipp/sip_update_within_icoming_reinvite_with_no_sdp.xml");
sipp_out = sip_start(scen, linphone_address_get_username(mgr->identity), mgr->identity);
if (sipp_out) {
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallIncomingReceived, 1));
linphone_core_accept_call(mgr->lc, linphone_core_get_current_call(mgr->lc));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallStreamsRunning, 2));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallEnd, 1));
pclose(sipp_out);
}
linphone_core_manager_destroy(mgr);
}
static void call_with_multiple_video_mline_in_sdp(void) {
LinphoneCoreManager *mgr;
char *identity_char;
char *scen;
FILE * sipp_out;
LinphoneCall *call = NULL;
/*currently we use direct connection because sipp do not properly set ACK request uri*/
mgr= linphone_core_manager_new2( "empty_rc", FALSE);
mgr->identity = linphone_core_get_primary_contact_parsed(mgr->lc);
linphone_address_set_username(mgr->identity,"marie");
identity_char = linphone_address_as_string(mgr->identity);
linphone_core_set_primary_contact(mgr->lc,identity_char);
linphone_core_iterate(mgr->lc);
scen = bc_tester_res("sipp/call_with_multiple_video_mline_in_sdp.xml");
sipp_out = sip_start(scen, linphone_address_get_username(mgr->identity), NULL, mgr->identity);
if (sipp_out) {
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallIncomingReceived, 1));
call = linphone_core_get_current_call(mgr->lc);
BC_ASSERT_PTR_NOT_NULL(call);
if (call) {
linphone_core_accept_call(mgr->lc, call);
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallStreamsRunning, 1));
BC_ASSERT_EQUAL(call->main_audio_stream_index, 0, int, "%d");
BC_ASSERT_EQUAL(call->main_video_stream_index, 1, int, "%d");
BC_ASSERT_TRUE(call->main_text_stream_index > 3);
BC_ASSERT_TRUE(linphone_call_log_video_enabled(linphone_call_get_call_log(call)));
check_rtcp(call);
}
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallEnd, 1));
pclose(sipp_out);
}
linphone_core_manager_destroy(mgr);
}
static void call_invite_200ok_without_contact_header(void) {
LinphoneCoreManager *mgr;
char *identity_char;
char *scen;
FILE * sipp_out;
LinphoneCall *call = NULL;
/*currently we use direct connection because sipp do not properly set ACK request uri*/
mgr= linphone_core_manager_new2("empty_rc", FALSE);
mgr->identity = linphone_core_get_primary_contact_parsed(mgr->lc);
linphone_address_set_username(mgr->identity,"marie");
identity_char = linphone_address_as_string(mgr->identity);
linphone_core_set_primary_contact(mgr->lc,identity_char);
linphone_core_iterate(mgr->lc);
scen = bc_tester_res("sipp/call_invite_200ok_without_contact_header.xml");
sipp_out = sip_start_recv(scen);
if (sipp_out) {
call = linphone_core_invite(mgr->lc, "[email protected]");
BC_ASSERT_PTR_NOT_NULL(call);
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallOutgoingInit, 1));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallOutgoingProgress, 1));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallOutgoingRinging, 1));
/*assert that the call never gets connected nor terminated*/
BC_ASSERT_FALSE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallConnected, 1));
BC_ASSERT_EQUAL(mgr->stat.number_of_LinphoneCallEnd, 0, int, "%d");
BC_ASSERT_EQUAL(mgr->stat.number_of_LinphoneCallError, 0, int, "%d");
linphone_core_terminate_call(mgr->lc, call);
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallEnd, 1));
BC_ASSERT_TRUE(wait_for(mgr->lc, mgr->lc, &mgr->stat.number_of_LinphoneCallReleased, 1));
pclose(sipp_out);
}
linphone_core_manager_destroy(mgr);
}
static void fileplay_soundwrite_from_file(const char *filepath){
char* file = bc_tester_res(filepath);
fileplay_soundwrite(file);
free(file);
}
void linphone_core_manager_init(LinphoneCoreManager *mgr, const char* rc_file) {
char *rc_path = NULL;
char *hellopath = bc_tester_res("sounds/hello8000.wav");
mgr->number_of_cunit_error_at_creation = bc_get_number_of_failures();
mgr->v_table.registration_state_changed=registration_state_changed;
mgr->v_table.auth_info_requested=auth_info_requested;
mgr->v_table.call_state_changed=call_state_changed;
mgr->v_table.text_received=text_message_received;
mgr->v_table.message_received=message_received;
mgr->v_table.is_composing_received=is_composing_received;
mgr->v_table.new_subscription_requested=new_subscription_requested;
mgr->v_table.notify_presence_received=notify_presence_received;
mgr->v_table.transfer_state_changed=linphone_transfer_state_changed;
mgr->v_table.info_received=info_message_received;
mgr->v_table.subscription_state_changed=linphone_subscription_state_change;
mgr->v_table.notify_received=linphone_notify_received;
mgr->v_table.publish_state_changed=linphone_publish_state_changed;
mgr->v_table.configuring_status=linphone_configuration_status;
mgr->v_table.call_encryption_changed=linphone_call_encryption_changed;
mgr->v_table.network_reachable=network_reachable;
mgr->v_table.dtmf_received=dtmf_received;
mgr->v_table.call_stats_updated=call_stats_updated;
reset_counters(&mgr->stat);
if (rc_file) rc_path = ms_strdup_printf("rcfiles/%s", rc_file);
mgr->lc=configure_lc_from(&mgr->v_table, bc_tester_get_resource_dir_prefix(), rc_path, mgr);
linphone_core_manager_check_accounts(mgr);
manager_count++;
#if TARGET_OS_IPHONE
linphone_core_set_ringer_device( mgr->lc, "AQ: Audio Queue Device");
linphone_core_set_ringback(mgr->lc, NULL);
#elif __QNX__
linphone_core_set_playback_device(mgr->lc, "QSA: voice");
#endif
#ifdef VIDEO_ENABLED
{
MSWebCam *cam;
cam = ms_web_cam_manager_get_cam(ms_factory_get_web_cam_manager(mgr->lc->factory), "Mire: Mire (synthetic moving picture)");
if (cam == NULL) {
MSWebCamDesc *desc = ms_mire_webcam_desc_get();
if (desc){
cam=ms_web_cam_new(desc);
ms_web_cam_manager_add_cam(ms_factory_get_web_cam_manager(mgr->lc->factory), cam);
}
}
}
#endif
linphone_core_set_play_file(mgr->lc,hellopath); /*is also used when in pause*/
ms_free(hellopath);
if( manager_count >= 2){
char *recordpath = ms_strdup_printf("%s/record_for_lc_%p.wav",bc_tester_get_writable_dir_prefix(),mgr->lc);
ms_message("Manager for '%s' using files", rc_file ? rc_file : "--");
linphone_core_set_use_files(mgr->lc, TRUE);
linphone_core_set_record_file(mgr->lc,recordpath);
ms_free(recordpath);
}
linphone_core_set_user_certificates_path(mgr->lc,bc_tester_get_writable_dir_prefix());
/*for now, we need the periodical updates facility to compute bandwidth measurements correctly during tests*/
lp_config_set_int(linphone_core_get_config(mgr->lc), "misc", "send_call_stats_periodical_updates", 1);
if (rc_path) ms_free(rc_path);
}
static void basic_audio_stream_base_2( const char* marielle_local_ip
, const char* marielle_remote_ip
, int marielle_local_rtp_port
, int marielle_remote_rtp_port
, int marielle_local_rtcp_port
, int marielle_remote_rtcp_port
, const char* margaux_local_ip
, const char* margaux_remote_ip
, int margaux_local_rtp_port
, int margaux_remote_rtp_port
, int margaux_local_rtcp_port
, int margaux_remote_rtcp_port
, int lost_percentage) {
AudioStream * marielle = audio_stream_new2 (_factory, marielle_local_ip, marielle_local_rtp_port, marielle_local_rtcp_port);
stats_t marielle_stats;
AudioStream * margaux = audio_stream_new2 (_factory, margaux_local_ip, margaux_local_rtp_port,margaux_local_rtcp_port);
stats_t margaux_stats;
RtpProfile* profile = rtp_profile_new("default profile");
char* hello_file = bc_tester_res(HELLO_8K_1S_FILE);
char* recorded_file = bc_tester_file(RECORDED_8K_1S_FILE);
uint64_t marielle_rtp_sent=0;
rtp_session_set_multicast_loopback(marielle->ms.sessions.rtp_session,TRUE);
rtp_session_set_multicast_loopback(margaux->ms.sessions.rtp_session,TRUE);
rtp_session_set_rtcp_report_interval(marielle->ms.sessions.rtp_session, 1000);
rtp_session_set_rtcp_report_interval(margaux->ms.sessions.rtp_session, 1000);
reset_stats(&marielle_stats);
reset_stats(&margaux_stats);
rtp_profile_set_payload (profile,0,&payload_type_pcmu8000);
BC_ASSERT_EQUAL(audio_stream_start_full(margaux
, profile
, ms_is_multicast(margaux_local_ip)?margaux_local_ip:margaux_remote_ip
, ms_is_multicast(margaux_local_ip)?margaux_local_rtp_port:margaux_remote_rtp_port
, margaux_remote_ip
, margaux_remote_rtcp_port
, 0
, 50
, NULL
, recorded_file
, NULL
, NULL
, 0)
,0, int, "%d");
BC_ASSERT_EQUAL(audio_stream_start_full(marielle
, profile
, marielle_remote_ip
, marielle_remote_rtp_port
, marielle_remote_ip
, marielle_remote_rtcp_port
, 0
, 50
, hello_file
, NULL
, NULL
, NULL
, 0)
,0, int, "%d");
ms_filter_add_notify_callback(marielle->soundread, notify_cb, &marielle_stats,TRUE);
wait_for_until(&marielle->ms,&margaux->ms,&marielle_stats.number_of_EndOfFile,1,12000);
audio_stream_get_local_rtp_stats(marielle,&marielle_stats.rtp);
audio_stream_get_local_rtp_stats(margaux,&margaux_stats.rtp);
marielle_rtp_sent = marielle_stats.rtp.sent;
if (rtp_session_rtcp_enabled(marielle->ms.sessions.rtp_session) && rtp_session_rtcp_enabled(margaux->ms.sessions.rtp_session)) {
BC_ASSERT_GREATER_STRICT(rtp_session_get_round_trip_propagation(marielle->ms.sessions.rtp_session),0,float,"%f");
BC_ASSERT_GREATER_STRICT(rtp_session_get_stats(marielle->ms.sessions.rtp_session)->recv_rtcp_packets,0,unsigned long long,"%llu");
}
void start_adaptive_stream(MSFormatType type, stream_manager_t ** pmarielle, stream_manager_t ** pmargaux,
int payload, int initial_bitrate, int max_bw, float loss_rate, int latency, float dup_ratio) {
int pause_time=0;
PayloadType* pt;
MediaStream *marielle_ms,*margaux_ms;
OrtpNetworkSimulatorParams params={0};
#if VIDEO_ENABLED
MSWebCam * marielle_webcam=mediastreamer2_tester_get_mire_webcam(ms_web_cam_manager_get());
#endif
stream_manager_t *marielle=*pmarielle=stream_manager_new(type);
stream_manager_t *margaux=*pmargaux=stream_manager_new(type);
char* file = bc_tester_res(HELLO_16K_1S_FILE);
char* recorded_file = bc_tester_file(RECORDED_16K_1S_FILE);
marielle->user_data = recorded_file;
params.enabled=TRUE;
params.loss_rate=loss_rate;
params.max_bandwidth=max_bw;
params.latency=latency;
if (type == MSAudio){
marielle_ms=&marielle->audio_stream->ms;
margaux_ms=&margaux->audio_stream->ms;
}else{
marielle_ms=&marielle->video_stream->ms;
margaux_ms=&margaux->video_stream->ms;
}
/* Disable avpf. */
pt = rtp_profile_get_payload(&rtp_profile, VP8_PAYLOAD_TYPE);
BC_ASSERT_PTR_NOT_NULL_FATAL(pt);
payload_type_unset_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
media_stream_enable_adaptive_bitrate_control(marielle_ms,TRUE);
media_stream_set_adaptive_bitrate_algorithm(marielle_ms, MSQosAnalyzerAlgorithmStateful);
rtp_session_set_duplication_ratio(marielle_ms->sessions.rtp_session, dup_ratio);
if (marielle->type == MSAudio){
audio_manager_start(marielle,payload,margaux->local_rtp,initial_bitrate,file,NULL);
ms_filter_call_method(marielle->audio_stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
audio_manager_start(margaux,payload,marielle->local_rtp,0,NULL,recorded_file);
}else{
#if VIDEO_ENABLED
marielle->video_stream->staticimage_webcam_fps_optimization = FALSE;
video_manager_start(marielle,payload,margaux->local_rtp,0,marielle_webcam);
video_stream_set_direction(margaux->video_stream, MediaStreamRecvOnly);
video_manager_start(margaux,payload,marielle->local_rtp,0,NULL);
#else
ms_fatal("Unsupported stream type [%s]",ms_format_type_to_string(marielle->type));
#endif
}
ms_qos_analyzer_set_on_action_suggested(ms_bitrate_controller_get_qos_analyzer(marielle_ms->rc),
qos_analyzer_on_action_suggested,
*pmarielle);
rtp_session_enable_network_simulation(margaux_ms->sessions.rtp_session,¶ms);
free(recorded_file);
free(file);
}
static void two_incoming_early_media_video_calls_test(void) {
char *ringback_path;
LinphoneCoreManager *marie;
LinphoneCoreManager *pauline;
LinphoneCoreManager *laure;
LinphoneCallParams *marie_params;
LinphoneCallParams *pauline_params;
LinphoneCallParams *laure_params;
LinphoneCall *call;
const MSList *calls_list;
marie = linphone_core_manager_new("marie_rc");
pauline = linphone_core_manager_new("pauline_tcp_rc");
laure = linphone_core_manager_new("laure_rc");
marie_params = configure_for_early_media_video_receiving(marie);
pauline_params = configure_for_early_media_video_sending(pauline);
laure_params = configure_for_early_media_video_sending(laure);
/* Configure early media audio to play ring during early-media and send remote ring back tone. */
linphone_core_set_ring_during_incoming_early_media(marie->lc, TRUE);
ringback_path = bc_tester_res("sounds/ringback.wav");
linphone_core_set_remote_ringback_tone(marie->lc, ringback_path);
ms_free(ringback_path);
/* Early media video call from pauline to marie. */
BC_ASSERT_TRUE(video_call_with_params(pauline, marie, pauline_params, NULL, FALSE));
/* Wait for 2s. */
wait_for_three_cores(marie->lc, pauline->lc, NULL, 2000);
/* Early media video call from laure to marie. */
BC_ASSERT_TRUE(video_call_with_params(laure, marie, laure_params, NULL, FALSE));
/* Wait for 2s. */
wait_for_three_cores(marie->lc, pauline->lc, laure->lc, 2000);
BC_ASSERT_EQUAL(linphone_core_get_calls_nb(marie->lc), 2, int, "%d");
if (linphone_core_get_calls_nb(marie->lc) == 2) {
calls_list = linphone_core_get_calls(marie->lc);
call = (LinphoneCall *)ms_list_nth_data(calls_list, 0);
BC_ASSERT_PTR_NOT_NULL(call);
if (call != NULL) {
LinphoneCallParams *params = linphone_call_params_copy(linphone_call_get_current_params(call));
linphone_call_params_set_audio_direction(params, LinphoneMediaDirectionSendRecv);
linphone_call_params_set_video_direction(params, LinphoneMediaDirectionSendRecv);
linphone_core_accept_call_with_params(marie->lc, call, params);
/* Wait for 5s. */
wait_for_three_cores(marie->lc, pauline->lc, laure->lc, 5000);
}
}
linphone_core_terminate_all_calls(marie->lc);
BC_ASSERT_TRUE(wait_for(marie->lc, pauline->lc, &marie->stat.number_of_LinphoneCallEnd, 1));
BC_ASSERT_TRUE(wait_for(marie->lc, pauline->lc, &pauline->stat.number_of_LinphoneCallEnd, 1));
BC_ASSERT_TRUE(wait_for(marie->lc, pauline->lc, &marie->stat.number_of_LinphoneCallReleased, 1));
BC_ASSERT_TRUE(wait_for(marie->lc, pauline->lc, &pauline->stat.number_of_LinphoneCallReleased, 1));
BC_ASSERT_TRUE(wait_for(marie->lc, laure->lc, &marie->stat.number_of_LinphoneCallEnd, 1));
BC_ASSERT_TRUE(wait_for(marie->lc, laure->lc, &laure->stat.number_of_LinphoneCallEnd, 1));
BC_ASSERT_EQUAL(marie->stat.number_of_video_windows_created, 2, int, "%d");
BC_ASSERT_EQUAL(pauline->stat.number_of_video_windows_created, 1, int, "%d");
BC_ASSERT_EQUAL(laure->stat.number_of_video_windows_created, 1, int, "%d");
linphone_call_params_unref(marie_params);
linphone_call_params_unref(pauline_params);
linphone_call_params_unref(laure_params);
linphone_core_manager_destroy(marie);
linphone_core_manager_destroy(pauline);
linphone_core_manager_destroy(laure);
}
