Sal * sal_init(){
belle_sip_listener_callbacks_t listener_callbacks;
Sal * sal=ms_new0(Sal,1);
/*belle_sip_object_enable_marshal_check(TRUE);*/
sal->auto_contacts=TRUE;
/*first create the stack, which initializes the belle-sip object's pool for this thread*/
belle_sip_set_log_handler(_belle_sip_log);
sal->stack = belle_sip_stack_new(NULL);
sal->user_agent=belle_sip_header_user_agent_new();
#if defined(PACKAGE_NAME) && defined(LINPHONE_VERSION)
belle_sip_header_user_agent_add_product(sal->user_agent, PACKAGE_NAME "/" LINPHONE_VERSION);
#endif
sal_append_stack_string_to_user_agent(sal);
belle_sip_object_ref(sal->user_agent);
sal->prov = belle_sip_stack_create_provider(sal->stack,NULL);
sal_nat_helper_enable(sal,TRUE);
memset(&listener_callbacks,0,sizeof(listener_callbacks));
listener_callbacks.process_dialog_terminated=process_dialog_terminated;
listener_callbacks.process_io_error=process_io_error;
listener_callbacks.process_request_event=process_request_event;
listener_callbacks.process_response_event=process_response_event;
listener_callbacks.process_timeout=process_timeout;
listener_callbacks.process_transaction_terminated=process_transaction_terminated;
listener_callbacks.process_auth_requested=process_auth_requested;
sal->listener=belle_sip_listener_create_from_callbacks(&listener_callbacks,sal);
belle_sip_provider_add_sip_listener(sal->prov,sal->listener);
sal->tls_verify=TRUE;
sal->tls_verify_cn=TRUE;
sal->refresher_retry_after=60000; /*default value in ms*/
sal->enable_sip_update=TRUE;
return sal;
}
static void enc_init(MSFilter *f){
SpeexEncState *s=ms_new0(SpeexEncState,1);
#ifdef SPEEX_LIB_SET_CPU_FEATURES
int cpuFeatures = 0;
#endif
s->rate=8000;
s->bitrate=-1;
s->maxbitrate=-1;
s->ip_bitrate=-1;
s->ptime=20;
s->mode=-1;
s->vbr=0;
s->cng=0;
s->frame_size=0;
s->state=0;
s->ts=0;
s->bufferizer=ms_bufferizer_new();
f->data=s;
#ifdef SPEEX_LIB_SET_CPU_FEATURES
#ifdef __ARM_NEON__
#ifdef ANDROID
if (android_getCpuFamily() == ANDROID_CPU_FAMILY_ARM
&& (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0) {
cpuFeatures = SPEEX_LIB_CPU_FEATURE_NEON;
}
#else
cpuFeatures = SPEEX_LIB_CPU_FEATURE_NEON;
#endif
#endif
ms_message("speex_lib_ctl init %s neon", (cpuFeatures == SPEEX_LIB_CPU_FEATURE_NEON)?"with":"without");
speex_lib_ctl(SPEEX_LIB_SET_CPU_FEATURES, &cpuFeatures);
#else
ms_message("speex_lib_ctl does not support SPEEX_LIB_CPU_FEATURE_NEON");
#endif
}
static void sender_init(MSFilter * f)
{
SenderData *d = (SenderData *)ms_new0(SenderData, 1);
const char *tmp=getenv("MS2_RTP_FIXED_DELAY");
d->session = NULL;
d->tsoff = 0;
d->skip_until = 0;
d->skip = FALSE;
d->rate = 8000;
d->nchannels = 1;
d->dtmf = 0;
d->dtmf_duration = 800;
d->dtmf_ts_step=160;
d->mute_mic=FALSE;
d->relay_session_id_size=0;
d->last_rsi_time=0;
d->last_sent_time=-1;
d->last_stun_sent_time = -1;
d->last_ts=0;
d->use_task= tmp ? (!!atoi(tmp)) : FALSE;
if (d->use_task) ms_message("MSRtpSend will use tasks to send out packet at the beginning of ticks.");
f->data = d;
}
static void ms_opus_enc_init(MSFilter *f) {
OpusEncData *d = (OpusEncData *)ms_new0(OpusEncData, 1);
d->bufferizer = ms_bufferizer_new();
d->state = NULL;
d->ts = 0;
d->samplerate = 48000;
d->application = OPUS_APPLICATION_VOIP; // property not really needed as we are always in this application mode
d->bitrate = -1;
d->max_network_bitrate = 46000;
/* set default parameters according to draft RFC RTP Payload Format for Opus codec section 6.1 */
d->maxplaybackrate = 48000;
d->maxptime = 120;
d->ptime = 20;
d->minptime = 20; // defaut shall be 3, but we never use less than 20.
d->maxaveragebitrate = -1;
d->stereo = 0; /*stereo=0 is the default mode in opus rtp draft*/
d->channels = 1;
d->vbr = 1;
d->useinbandfec = 0;
d->usedtx = 0;
f->data = d;
}
static void enc_init(MSFilter *f) {
vpx_codec_err_t res;
EncState *s=(EncState *)ms_new0(EncState,1);
ms_message("Using %s\n",vpx_codec_iface_name(interface));
/* Populate encoder configuration */
res = vpx_codec_enc_config_default(interface, &s->cfg, 0);
if(res) {
ms_error("Failed to get config: %s\n", vpx_codec_err_to_string(res));
}
s->width = MS_VIDEO_SIZE_CIF_W;
s->height = MS_VIDEO_SIZE_CIF_H;
s->bitrate=256000;
s->frame_count = 0;
s->cfg.g_w = s->width;
s->cfg.g_h = s->height;
/* encoder automatically places keyframes */
s->cfg.kf_mode = VPX_KF_AUTO;
s->cfg.kf_max_dist = 300;
s->cfg.rc_target_bitrate = ((float)s->bitrate)*0.92/1024.0; //0.9=take into account IP/UDP/RTP overhead, in average.
s->cfg.g_pass = VPX_RC_ONE_PASS; /* -p 1 */
s->fps=15;
s->cfg.g_timebase.num = 1;
s->cfg.g_timebase.den = s->fps;
s->cfg.rc_end_usage = VPX_CBR; /* --end-usage=cbr */
s->cfg.g_threads = ms_get_cpu_count();
ms_message("VP8 g_threads=%d", s->cfg.g_threads);
s->cfg.rc_undershoot_pct = 95; /* --undershoot-pct=95 */
s->cfg.g_error_resilient = 1;
s->cfg.g_lag_in_frames = 0;
s->mtu=ms_get_payload_max_size()-1;/*-1 for the vp8 payload header*/
f->data = s;
}
BuddyInfo *buddy_info_new(){
return ms_new0(BuddyInfo,1);
}
LinphoneInfoMessage *linphone_info_message_copy(const LinphoneInfoMessage *orig){
LinphoneInfoMessage *im=ms_new0(LinphoneInfoMessage,1);
linphone_content_copy(&im->content,&orig->content);
if (orig->headers) im->headers=sal_custom_header_clone(orig->headers);
return im;
}
SalMediaDescription *sal_media_description_new(){
SalMediaDescription *md=ms_new0(SalMediaDescription,1);
md->refcount=1;
return md;
}
ConfSoundCard *local_sound_card_new()
{
ConfSoundCard *sndcard=ms_new0(ConfSoundCard,1);
sndcard->audio_port_index = -1;
return sndcard;
}
MSYuvBufAllocator *ms_yuv_buf_allocator_new(void) {
msgb_allocator_t *allocator = (msgb_allocator_t *)ms_new0(msgb_allocator_t, 1);
msgb_allocator_init(allocator);
return allocator;
}
LinphoneCoreManager* linphone_core_manager_new2(const char* rc_file, int check_for_proxies) {
LinphoneCoreManager* mgr= ms_new0(LinphoneCoreManager,1);
LinphoneProxyConfig* proxy;
char *rc_path = NULL;
int proxy_count;
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, liblinphone_tester_file_prefix, rc_path, mgr);
linphone_core_manager_check_accounts(mgr);
/*CU_ASSERT_EQUAL(ms_list_size(linphone_core_get_proxy_config_list(lc)),proxy_count);*/
if (check_for_proxies && rc_file) /**/
proxy_count=ms_list_size(linphone_core_get_proxy_config_list(mgr->lc));
else
proxy_count=0;
manager_count++;
#if TARGET_OS_IPHONE
linphone_core_set_ringer_device( mgr->lc, "AQ: Audio Queue Device");
linphone_core_set_ringback(mgr->lc, NULL);
#endif
if( manager_count >= 2){
char hellopath[512];
ms_message("Manager for '%s' using files", rc_file ? rc_file : "--");
linphone_core_use_files(mgr->lc, TRUE);
snprintf(hellopath,sizeof(hellopath), "%s/sounds/hello8000.wav", liblinphone_tester_file_prefix);
linphone_core_set_play_file(mgr->lc,hellopath);
}
if (proxy_count){
#define REGISTER_TIMEOUT 20 /* seconds */
int success = wait_for_until(mgr->lc,NULL,&mgr->stat.number_of_LinphoneRegistrationOk,
proxy_count,(REGISTER_TIMEOUT * 1000 * proxy_count));
if( !success ){
ms_error("Did not register after %d seconds for %d proxies", REGISTER_TIMEOUT, proxy_count);
}
}
CU_ASSERT_EQUAL(mgr->stat.number_of_LinphoneRegistrationOk,proxy_count);
enable_codec(mgr->lc,"PCMU",8000);
linphone_core_get_default_proxy(mgr->lc,&proxy);
if (proxy) {
mgr->identity = linphone_address_new(linphone_proxy_config_get_identity(proxy));
linphone_address_clean(mgr->identity);
}
if (rc_path) ms_free(rc_path);
return mgr;
}
static bool_t stateful_analyzer_process_rtcp(MSQosAnalyzer *objbase, mblk_t *rtcp){
MSStatefulQosAnalyzer *obj=(MSStatefulQosAnalyzer*)objbase;
const report_block_t *rb=NULL;
if (rtcp_is_SR(rtcp)){
rb=rtcp_SR_get_report_block(rtcp,0);
}else if (rtcp_is_RR(rtcp)){
rb=rtcp_RR_get_report_block(rtcp,0);
}
if (rb && report_block_get_ssrc(rb)==rtp_session_get_send_ssrc(obj->session)){
if (ortp_loss_rate_estimator_process_report_block(objbase->lre,&obj->session->rtp,rb)){
int i;
float loss_rate = ortp_loss_rate_estimator_get_value(objbase->lre);
float up_bw = stateful_qos_analyzer_upload_bandwidth(obj,report_block_get_high_ext_seq(rb));
obj->curindex++;
/*flush bandwidth estimation measures for seq number lower than remote report block received*/
for (i=0;i<BW_HISTORY;i++){
if (obj->upload_bandwidth[i].seq_number<report_block_get_high_ext_seq(rb)){
obj->upload_bandwidth[i].seq_number=0;
obj->upload_bandwidth[i].up_bandwidth=0.f;
}
}
/* Always skip the first report, since values might be erroneous due
to initialization of multiples objects (encoder/decoder/stats computing..)
Instead assume loss rate is a good estimation of network capacity */
if (obj->curindex==1) {
obj->network_loss_rate=loss_rate;
return TRUE;
}
obj->latest=ms_new0(rtcpstatspoint_t, 1);
obj->latest->timestamp=ms_time(0);
obj->latest->bandwidth=up_bw;
obj->latest->loss_percent=loss_rate;
obj->latest->rtt=rtp_session_get_round_trip_propagation(obj->session);
obj->rtcpstatspoint=ms_list_insert_sorted(obj->rtcpstatspoint,
obj->latest, (MSCompareFunc)sort_by_bandwidth);
/*if the measure was 0% loss, reset to 0% every measures below it*/
if (obj->latest->loss_percent < 1e-5){
MSList *it=obj->rtcpstatspoint;
MSList *latest_pos=ms_list_find(obj->rtcpstatspoint,obj->latest);
while (it!=latest_pos->next){
((rtcpstatspoint_t *)it->data)->loss_percent=0.f;
it = it->next;
}
}
ms_message("MSStatefulQosAnalyzer[%p]: one more %d: %f %f",
obj, obj->curindex-1, obj->latest->bandwidth, obj->latest->loss_percent);
if (ms_list_size(obj->rtcpstatspoint) > ESTIM_HISTORY){
int prev_size = ms_list_size(obj->rtcpstatspoint);
/*clean everything which occurred 60 sec or more ago*/
time_t clear_time = ms_time(0) - 60;
obj->rtcpstatspoint = ms_list_remove_custom(obj->rtcpstatspoint,
(MSCompareFunc)earlier_than, &clear_time);
ms_message("MSStatefulQosAnalyzer[%p]: reached list maximum capacity "
"(count=%d) --> Cleaned list (count=%d)",
obj, prev_size, ms_list_size(obj->rtcpstatspoint));
}
return TRUE;
}
}
return FALSE;
}
LinphoneChatMessage* linphone_chat_room_create_message(const LinphoneChatRoom *cr,const char* message) {
LinphoneChatMessage* msg = ms_new0(LinphoneChatMessage,1);
msg->chat_room=(LinphoneChatRoom*)cr;
msg->message=message?ms_strdup(message):NULL;
return msg;
}
LinphoneCoreManager* linphone_core_manager_init(const char* rc_file) {
LinphoneCoreManager* mgr= ms_new0(LinphoneCoreManager,1);
char *rc_path = NULL;
mgr->number_of_cunit_error_at_creation = CU_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_read_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);
#endif
#ifdef VIDEO_ENABLED
{
MSWebCam *cam;
cam = ms_web_cam_manager_get_cam(ms_web_cam_manager_get(), "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_web_cam_manager_get(), cam);
}
}
}
#endif
if( manager_count >= 2){
char hellopath[512];
char *recordpath = ms_strdup_printf("%s/record_for_lc_%p.wav",bc_tester_writable_dir_prefix,mgr->lc);
ms_message("Manager for '%s' using files", rc_file ? rc_file : "--");
linphone_core_use_files(mgr->lc, TRUE);
snprintf(hellopath,sizeof(hellopath), "%s/sounds/hello8000.wav", bc_tester_read_dir_prefix);
linphone_core_set_play_file(mgr->lc,hellopath);
linphone_core_set_record_file(mgr->lc,recordpath);
ms_free(recordpath);
}
linphone_core_set_user_certificates_path(mgr->lc,bc_tester_writable_dir_prefix);
if (rc_path) ms_free(rc_path);
return mgr;
}
MSBitrateController *ms_bitrate_controller_new(MSQosAnalyzer *qosanalyzer, MSBitrateDriver *driver){
MSBitrateController *obj=ms_new0(MSBitrateController,1);
obj->analyzer=ms_qos_analyzer_ref(qosanalyzer);
obj->driver=ms_bitrate_driver_ref(driver);
return obj;
}
static void au_write_init(MSFilter *f) {
AUWrite *d = ms_new0(AUWrite, 1);
au_common_init(&d->common);
d->buffer=ms_bufferizer_new();
f->data=d;
}
MSFactory *ms_factory_new(void){
MSFactory *obj=ms_new0(MSFactory,1);
ms_factory_init(obj);
return obj;
}
static void enc_process(MSFilter *f) {
mblk_t *im;
uint64_t timems = f->ticker->time;
uint32_t timestamp = (uint32_t)(timems*90);
EncState *s = (EncState *)f->data;
unsigned int flags = 0;
vpx_codec_err_t err;
MSPicture yuv;
bool_t is_ref_frame=FALSE;
ms_filter_lock(f);
#ifdef AVPF_DEBUG
ms_message("VP8 enc_process:");
#endif
if (!s->ready) {
ms_queue_flush(f->inputs[0]);
ms_filter_unlock(f);
return;
}
if ((im = ms_queue_peek_last(f->inputs[0])) != NULL) {
vpx_image_t img;
flags = 0;
ms_yuv_buf_init_from_mblk(&yuv, im);
vpx_img_wrap(&img, VPX_IMG_FMT_I420, s->vconf.vsize.width, s->vconf.vsize.height, 1, yuv.planes[0]);
if ((s->avpf_enabled != TRUE) && ms_video_starter_need_i_frame(&s->starter, f->ticker->time)) {
s->force_keyframe = TRUE;
}
if (s->force_keyframe == TRUE) {
ms_message("Forcing vp8 key frame for filter [%p]", f);
flags = VPX_EFLAG_FORCE_KF;
} else if (s->avpf_enabled == TRUE) {
if (s->frame_count == 0) s->force_keyframe = TRUE;
enc_fill_encoder_flags(s, &flags);
}
#ifdef AVPF_DEBUG
ms_message("VP8 encoder frames state:");
ms_message("\tgolden: count=%" PRIi64 ", picture_id=0x%04x, ack=%s",
s->frames_state.golden.count, s->frames_state.golden.picture_id, (s->frames_state.golden.acknowledged == TRUE) ? "Y" : "N");
ms_message("\taltref: count=%" PRIi64 ", picture_id=0x%04x, ack=%s",
s->frames_state.altref.count, s->frames_state.altref.picture_id, (s->frames_state.altref.acknowledged == TRUE) ? "Y" : "N");
#endif
err = vpx_codec_encode(&s->codec, &img, s->frame_count, 1, flags, 1000000LL/(2*(int)s->vconf.fps)); /*encoder has half a framerate interval to encode*/
if (err) {
ms_error("vpx_codec_encode failed : %d %s (%s)\n", err, vpx_codec_err_to_string(err), vpx_codec_error_detail(&s->codec));
} else {
vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt;
MSList *list = NULL;
/* Update the frames state. */
is_ref_frame=FALSE;
if (flags & VPX_EFLAG_FORCE_KF) {
enc_mark_reference_frame_as_sent(s, VP8_GOLD_FRAME);
enc_mark_reference_frame_as_sent(s, VP8_ALTR_FRAME);
s->frames_state.golden.is_independant=TRUE;
s->frames_state.altref.is_independant=TRUE;
s->frames_state.last_independent_frame=s->frame_count;
s->force_keyframe = FALSE;
is_ref_frame=TRUE;
}else if (flags & VP8_EFLAG_FORCE_GF) {
enc_mark_reference_frame_as_sent(s, VP8_GOLD_FRAME);
is_ref_frame=TRUE;
}else if (flags & VP8_EFLAG_FORCE_ARF) {
enc_mark_reference_frame_as_sent(s, VP8_ALTR_FRAME);
is_ref_frame=TRUE;
}else if (flags & VP8_EFLAG_NO_REF_LAST) {
enc_mark_reference_frame_as_sent(s, VP8_LAST_FRAME);
is_ref_frame=is_reconstruction_frame_sane(s,flags);
}
if (is_frame_independent(flags)){
s->frames_state.last_independent_frame=s->frame_count;
}
/* Pack the encoded frame. */
while( (pkt = vpx_codec_get_cx_data(&s->codec, &iter)) ) {
if ((pkt->kind == VPX_CODEC_CX_FRAME_PKT) && (pkt->data.frame.sz > 0)) {
Vp8RtpFmtPacket *packet = ms_new0(Vp8RtpFmtPacket, 1);
packet->m = allocb(pkt->data.frame.sz, 0);
memcpy(packet->m->b_wptr, pkt->data.frame.buf, pkt->data.frame.sz);
packet->m->b_wptr += pkt->data.frame.sz;
mblk_set_timestamp_info(packet->m, timestamp);
packet->pd = ms_new0(Vp8RtpFmtPayloadDescriptor, 1);
packet->pd->start_of_partition = TRUE;
packet->pd->non_reference_frame = s->avpf_enabled && !is_ref_frame;
if (s->avpf_enabled == TRUE) {
packet->pd->extended_control_bits_present = TRUE;
packet->pd->pictureid_present = TRUE;
packet->pd->pictureid = s->picture_id;
} else {
packet->pd->extended_control_bits_present = FALSE;
packet->pd->pictureid_present = FALSE;
}
if (s->flags & VPX_CODEC_USE_OUTPUT_PARTITION) {
packet->pd->pid = (uint8_t)pkt->data.frame.partition_id;
if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
mblk_set_marker_info(packet->m, TRUE);
}
} else {
packet->pd->pid = 0;
mblk_set_marker_info(packet->m, TRUE);
}
list = ms_list_append(list, packet);
}
}
#ifdef AVPF_DEBUG
ms_message("VP8 encoder picture_id=%i ***| %s | %s | %s | %s", (int)s->picture_id,
(flags & VPX_EFLAG_FORCE_KF) ? "KF " : (flags & VP8_EFLAG_FORCE_GF) ? "GF " : (flags & VP8_EFLAG_FORCE_ARF) ? "ARF" : " ",
(flags & VP8_EFLAG_NO_REF_GF) ? "NOREFGF" : " ",
(flags & VP8_EFLAG_NO_REF_ARF) ? "NOREFARF" : " ",
(flags & VP8_EFLAG_NO_REF_LAST) ? "NOREFLAST" : " ");
#endif
vp8rtpfmt_packer_process(&s->packer, list, f->outputs[0], f->factory);
/* Handle video starter if AVPF is not enabled. */
s->frame_count++;
if ((s->avpf_enabled != TRUE) && (s->frame_count == 1)) {
ms_video_starter_first_frame(&s->starter, f->ticker->time);
}
/* Increment the pictureID. */
s->picture_id++;
#ifdef PICTURE_ID_ON_16_BITS
if (s->picture_id == 0)
s->picture_id = 0x8000;
#else
if (s->picture_id == 0x0080)
s->picture_id = 0;
#endif
}
}
ms_filter_unlock(f);
ms_queue_flush(f->inputs[0]);
}
VideoPreview * video_preview_new(void){
VideoPreview *stream = (VideoPreview *)ms_new0 (VideoPreview, 1);
MS_VIDEO_SIZE_ASSIGN(stream->sent_vsize, CIF);
choose_display_name(stream);
return stream;
}
static MSWebCamManager * create_manager(void){
MSWebCamManager *obj=(MSWebCamManager *)ms_new0(MSWebCamManager,1);
return obj;
}
ConfWebCam *local_webcam_new(){
ConfWebCam *webcam=ms_new0(ConfWebCam,1);
webcam->video_port_index = -1;
return webcam;
}
static MSVideoPreset * add_video_preset(MSVideoPresetsManager *manager, const char *name) {
MSVideoPreset *vp = ms_new0(MSVideoPreset, 1);
vp->name = ms_strdup(name);
manager->presets = ms_list_append(manager->presets, vp);
return vp;
}
SalAuthInfo* sal_auth_info_new() {
return ms_new0(SalAuthInfo,1);
}
static void add_video_preset_configuration(MSVideoPreset *preset, const char *tags, MSVideoConfiguration *config) {
MSVideoPresetConfiguration *vpc = ms_new0(MSVideoPresetConfiguration, 1);
vpc->tags = parse_tags(tags);
vpc->config = config;
preset->configs = ms_list_append(preset->configs, vpc);
}
int ms_audio_diff(const char *file1, const char *file2, double *ret, int max_shift_percent, MSAudioDiffProgressNotify func, void *user_data){
FileInfo *fi1,*fi2;
int64_t *xcorr;
int xcorr_size;
int max_shift_samples;
int max_index_r;
int max_index_l;
double max_r, max_l;
*ret=0;
fi1=file_info_new(file1);
if (fi1==NULL) return 0;
fi2=file_info_new(file2);
if (fi2==NULL){
file_info_destroy(fi1);
return -1;
}
if (fi1->rate!=fi2->rate){
ms_error("Comparing files of different sampling rates is not supported (%d vs %d)", fi1->rate, fi2->rate);
return -1;
}
if (fi1->nchannels!=fi2->nchannels){
ms_error("Comparing files with different number of channels is not supported (%d vs %d)", fi1->nchannels, fi2->nchannels);
return -1;
}
file_info_compute_energy(fi1);
file_info_compute_energy(fi2);
if (fi1->energy_r==0 || fi2->energy_r==0){
/*avoid division by zero*/
ms_error("One of the two files is pure silence.");
return -1;
}
max_shift_samples = MIN(fi1->nsamples, fi2->nsamples) * MIN(MAX(1, max_shift_percent), 100) / 100;
xcorr_size=max_shift_samples*2;
xcorr=ms_new0(int64_t,xcorr_size);
if (fi1->nchannels == 2){
max_index_r=compute_cross_correlation_interleaved(fi1->buffer,fi1->nsamples,fi2->buffer,fi2->nsamples,xcorr,xcorr_size, func, user_data, 0, max_shift_samples);
max_r=xcorr[max_index_r];
ms_message("max_r=%g", (double)max_r);
max_r/=sqrt((double)fi1->energy_r*(double)fi2->energy_r);
max_index_l=compute_cross_correlation_interleaved(fi1->buffer,fi1->nsamples,fi2->buffer,fi2->nsamples,xcorr,xcorr_size, func, user_data, 1, max_shift_samples);
max_l=xcorr[max_index_l];
ms_message("max_l=%g", (double)max_l);
max_l/=sqrt((double)fi1->energy_l*(double)fi2->energy_l);
ms_message("Max stereo cross-correlation obtained at position [%i,%i], similarity factor=%g,%g",
max_index_r-max_shift_samples,max_index_l-max_shift_samples,max_r, max_l);
*ret = 0.5 * (fabs(max_r) + fabs(max_l)) * (1 - (double)abs(max_index_r-max_index_l)/(double)xcorr_size);
}else{
max_index_r=compute_cross_correlation(fi1->buffer,fi1->nsamples,fi2->buffer,fi2->nsamples,xcorr,xcorr_size, func, user_data, max_shift_samples);
max_r=xcorr[max_index_r];
max_r/=(sqrt(fi1->energy_r)*sqrt(fi2->energy_r));
*ret=max_r;
ms_message("Max cross-correlation obtained at position [%i], similarity factor=%g",max_index_r-max_shift_samples,*ret);
}
ms_free(xcorr);
file_info_destroy(fi1);
file_info_destroy(fi2);
return 0;
}
static void ms_rtt_4103_sink_init(MSFilter *f) {
RealTimeTextSinkData *s = ms_new0(RealTimeTextSinkData, 1);
s->pt_red = 0;
s->pt_t140 = 0;
f->data = s;
}
/**
* Creates an empty info message.
* @param lc the LinphoneCore
* @return a new LinphoneInfoMessage.
*
* The info message can later be filled with information using linphone_info_message_add_header() or linphone_info_message_set_content(),
* and finally sent with linphone_core_send_info_message().
**/
LinphoneInfoMessage *linphone_core_create_info_message(LinphoneCore *lc){
LinphoneInfoMessage *im=ms_new0(LinphoneInfoMessage,1);
return im;
}
static void au_card_init(MSSndCard * card)
{
AuCard *c = (AuCard *) ms_new0(AuCard, 1);
c->removed = 0;
card->data = c;
}
MSList *ms_list_new(void *data){
MSList *new_elem=(MSList *)ms_new0(MSList,1);
new_elem->data=data;
return new_elem;
}
static void au_read_init(MSFilter *f) {
AURead *d = ms_new0(AURead, 1);
au_common_init(&d->common);
qinit(&d->rq);
f->data=d;
}
